dd_access_map.h

Go to the documentation of this file.

 
#ifndef DD_DD_ACCESS_MAP_H_INCLUDED
#define DD_DD_ACCESS_MAP_H_INCLUDED
 
#include <ddl/dd/dd_error.h>
#include <ddl/utilities/dd_access_observer.h>
 
#include <memory>
#include <unordered_map>
 
namespace ddl {
namespace dd {
namespace utility {
 
enum TypeAccessMapEventCode {
    map_item_added,
    map_item_removed,
    map_item_changed,
    map_item_renamed,
    map_subitem_added,
    map_subitem_removed,
    map_subitem_changed,
    map_subitem_renamed,
    map_subitem_popped,
    map_subitem_inserted
};
 
template <typename T>
using TypeAccessMapSubject = ModelSubjectUtility<T, TypeAccessMapEventCode>;
 
template <typename T>
using TypeAccessMapObserver = ModelObserverUtility<T, TypeAccessMapEventCode>;
 
template <typename DDL_TYPE_TO_ACCESS, typename TYPE_VALIDATOR_CLASS>
class TypeAccessMap : public TypeAccessMapObserver<DDL_TYPE_TO_ACCESS> {
public:
    typedef DDL_TYPE_TO_ACCESS access_type;
    typedef std::shared_ptr<DDL_TYPE_TO_ACCESS> value_type;
    typedef std::unordered_map<std::string, value_type> container_type;
    typedef typename container_type::iterator iterator;
    typedef typename container_type::const_iterator const_iterator;
    typedef TypeAccessMapObserver<DDL_TYPE_TO_ACCESS> parent_type;
    typedef TypeAccessMapSubject<DDL_TYPE_TO_ACCESS> map_subject_type;
    typedef typename map_subject_type::observer_type observer_type;
    typedef typename parent_type::event_code_type event_code_type;
    typedef typename parent_type::subject_type subject_type;
    friend TYPE_VALIDATOR_CLASS;
 
public:
    TypeAccessMap() = delete;
    TypeAccessMap(TYPE_VALIDATOR_CLASS* validator, const std::string& validation_info)
        : _validator(validator), _validation_info(validation_info)
    {
    }
    virtual ~TypeAccessMap()
    {
        clear();
    }
    TypeAccessMap(TypeAccessMap&& other)
    {
        *this = std::move(other);
    }
    TypeAccessMap& operator=(TypeAccessMap&& other)
    {
        clear();
        _validation_info = std::move(other._validation_info);
        _types = std::move(other._types);
        // the other will remove itself as observer with clear
        for (const auto& current: _types) {
            // the other will not observe this anymore
            (static_cast<map_subject_type*>(current.second.get()))
                ->detachObserver(static_cast<observer_type*>(&other));
            // i want to observe this
            (static_cast<map_subject_type*>(current.second.get()))
                ->attachObserver(static_cast<observer_type*>(this));
        }
        _validator = nullptr;
        return *this;
    }
 
    TypeAccessMap(const TypeAccessMap& other)
        : _validator(nullptr), _validation_info(other._validation_info)
    {
        for (auto current: other._types) {
            auto new_type = std::make_shared<DDL_TYPE_TO_ACCESS>(*current.second);
            // i want to observe this
            (static_cast<map_subject_type*>(new_type.get()))
                ->attachObserver(static_cast<observer_type*>(this));
            _types[current.first] = new_type;
        }
    }
    TypeAccessMap& operator=(const TypeAccessMap& other)
    {
        clear();
        _validation_info = other._validation_info;
        for (auto current: other._types) {
            auto new_type = std::make_shared<DDL_TYPE_TO_ACCESS>(*current.second);
            // i want to observe this
            (static_cast<map_subject_type*>(new_type.get()))
                ->attachObserver(static_cast<observer_type*>(this));
            _types[current.first] = new_type;
        }
        _validator = nullptr;
        return *this;
    }
 
public:
    std::shared_ptr<const DDL_TYPE_TO_ACCESS> get(const std::string& type_name) const
    {
        auto it_find = _types.find(type_name);
        if (it_find != _types.cend()) {
            std::shared_ptr<const DDL_TYPE_TO_ACCESS> const_return = it_find->second;
            return const_return;
        }
        return {};
    }
    bool contains(const std::string& type_name) const
    {
        const auto& it_find = _types.find(type_name);
        if (it_find != _types.cend()) {
            return true;
        }
        return false;
    }
    bool contains(const DDL_TYPE_TO_ACCESS& type_to_find) const
    {
        const auto& it_find = _types.find(type_to_find.getName());
        if (it_find != _types.cend()) {
            return type_to_find == *(it_find->second);
        }
        return false;
    }
    bool contains(const TypeAccessMap& other) const
    {
        for (const auto& other_content: other._types) {
            if (!contains(*(other_content.second))) {
                return false;
            }
        }
        return true;
    }
    void add(const DDL_TYPE_TO_ACCESS& type_to_add)
    {
        const auto type_found = get(type_to_add.getName());
        // have a look if the type already exists here
        if (type_found) {
            // check if they are equal
            if (*type_found != type_to_add) {
                throw ddl::dd::Error(_validation_info + "::add",
                                     {type_to_add.getName()},
                                     "value with the given name already exists");
            }
            return;
        }
        else {
            // has already another type
            bool already_exists = contains(type_to_add.getName());
            if (_validator && !already_exists) {
                already_exists = _validator->validateContains(type_to_add);
            }
            if (already_exists) {
                throw ddl::dd::Error(_validation_info + "::add",
                                     {type_to_add.getName()},
                                     "value with the given name already exists");
            }
        }
        auto new_type_value = std::make_shared<DDL_TYPE_TO_ACCESS>(type_to_add);
        // i want to observe this
        (static_cast<map_subject_type*>(new_type_value.get()))
            ->attachObserver(static_cast<observer_type*>(this));
        _types[type_to_add.getName()] = new_type_value;
        if (_validator) {
            _validator->notifyChangedMapContent(
                TypeAccessMapEventCode::map_item_added, *new_type_value, type_to_add.getName());
        }
    }
 
    void emplace(DDL_TYPE_TO_ACCESS&& type_to_add)
    {
        const auto type_found = get(type_to_add.getName());
        // have a look if the type already exists here
        if (type_found) {
            // check if they are equal
            if (*type_found != type_to_add) {
                throw ddl::dd::Error(_validation_info + "::add",
                                     {type_to_add.getName()},
                                     "value with the given name already exists");
            }
        }
        else {
            // has already another type
            bool already_exists = contains(type_to_add.getName());
            if (_validator && !already_exists) {
                already_exists = _validator->validateContains(type_to_add);
            }
            if (already_exists) {
                throw ddl::dd::Error(_validation_info + "::add",
                                     {type_to_add.getName()},
                                     "value with the given name already exists");
            }
        }
        auto new_type_value = std::make_shared<DDL_TYPE_TO_ACCESS>(std::move(type_to_add));
        // i want to observe this
        (static_cast<map_subject_type*>(new_type_value.get()))
            ->attachObserver(static_cast<observer_type*>(this));
        _types[new_type_value->getName()] = new_type_value;
        if (_validator) {
            _validator->notifyChangedMapContent(
                TypeAccessMapEventCode::map_item_added, *new_type_value, new_type_value->getName());
        }
    }
    void remove(const std::string& type_name)
    {
        auto removed_value = access(type_name);
        if (removed_value) {
            _types.erase(type_name);
            (static_cast<map_subject_type*>(removed_value.get()))
                ->detachObserver(static_cast<observer_type*>(this));
            if (_validator) {
                _validator->notifyChangedMapContent(
                    TypeAccessMapEventCode::map_item_removed, *removed_value, type_name);
            }
            return;
        }
        throw ddl::dd::Error(
            _validation_info + "::remove", {type_name}, "value with the given name does not exist");
    }
    std::shared_ptr<DDL_TYPE_TO_ACCESS> access(const std::string& type_name)
    {
        auto it_find = _types.find(type_name);
        if (it_find != _types.end()) {
            return it_find->second;
        }
        return {};
    }
    size_t getSize() const
    {
        return _types.size();
    }
    iterator begin()
    {
        return _types.begin();
    }
    iterator end()
    {
        return _types.end();
    }
    const_iterator cbegin() const
    {
        return _types.cbegin();
    }
    const_iterator cend() const
    {
        return _types.cend();
    }
    const_iterator begin() const
    {
        return cbegin();
    }
    const_iterator end() const
    {
        return cend();
    }
    bool operator==(const TypeAccessMap& other) const
    {
        if (getSize() != other.getSize()) {
            return false;
        }
        else {
            return contains(other);
        }
    }
    bool operator!=(const TypeAccessMap& other) const
    {
        return !operator==(other);
    }
    void clear()
    {
        for (auto& current: _types) {
            // unregister me as observer
            (static_cast<map_subject_type*>(current.second.get()))
                ->detachObserver(static_cast<observer_type*>(this));
        }
        _types.clear();
    }
 
public:
    void modelChanged(event_code_type event_code,
                      subject_type& subject_changed,
                      const std::string& additional_info)
    {
        if (event_code == map_item_renamed) {
            bool already_exists = contains(subject_changed.getName());
            if (_validator && !already_exists) {
                already_exists = _validator->validateContains(subject_changed);
            }
            if (already_exists) {
                throw ddl::dd::Error(
                    _validation_info + "::modelChanged",
                    {subject_changed.getName()},
                    "Renaming not possible. Value with the given name already exists");
            }
            else {
                // here additional info is the old name
                iterator current = _types.find(additional_info);
                // we need to readd it
                auto value = current->second;
                _types.erase(current);
                _types[value->getName()] = value;
                // after erasing do not touch the iterator anymore
            }
        }
        if (_validator) {
            // i should discover the shared_ptr here, but not needed at the moment .. so we try to
            // get performance here
            _validator->notifyChangedMapContent(event_code, subject_changed, additional_info);
        }
    }
 
private:
    void deepCopy(TypeAccessMap& destination, TYPE_VALIDATOR_CLASS* validator) const
    {
        destination = *this;
        destination._validator = validator;
    }
    container_type _types;
    TYPE_VALIDATOR_CLASS* _validator;
    std::string _validation_info;
};
 
} // namespace utility
} // namespace dd
} // namespace ddl
 
#endif // DD_DD_ACCESS_MAP_H_INCLUDED