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/utilities/access_observer.h>
#include <ddl/utilities/access_validation.h>
#include <ddl/utilities/ddl_error.h>
 
#include <memory>
#include <sstream>
#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,
    map_item_removing,
    map_subitem_removing,
    map_item_renaming,
    map_subitem_renaming
};

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;
    }

    std::shared_ptr<DDL_TYPE_TO_ACCESS> create(const DDL_TYPE_TO_ACCESS& type_to_add)
    {
        const auto type_found = access(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 + "::create",
                    {type_to_add.getName()},
                    "value with the given name already exists and differs in " +
                        detail::TypeValidationInfo<DDL_TYPE_TO_ACCESS>::getDifference(*type_found,
                                                                                      type_to_add));
            }
            return type_found;
        }
        else {
            const bool already_exists_other_type =
                _validator && _validator->validateContains(type_to_add);
            if (already_exists_other_type) {
                throw ddl::dd::Error(
                    _validation_info + "::create",
                    {type_to_add.getName()},
                    std::string("value with the given name already exists with another type of ") +
                        detail::TypeValidationInfo<DDL_TYPE_TO_ACCESS>::_other_types);
            }
        }
        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());
        }
        return new_type_value;
    }

    void add(const DDL_TYPE_TO_ACCESS& type_to_add)
    {
        create(type_to_add);
    }

    std::shared_ptr<DDL_TYPE_TO_ACCESS> create(DDL_TYPE_TO_ACCESS&& type_to_add)
    {
        const auto type_found = access(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 + "::create",
                    {type_to_add.getName()},
                    "value with the given name already exists and differs in " +
                        detail::TypeValidationInfo<DDL_TYPE_TO_ACCESS>::getDifference(*type_found,
                                                                                      type_to_add));
            }
            return type_found;
        }
        else {
            // has already another type ? 
            const bool already_exists_other_type =
                _validator && _validator->validateContains(type_to_add);
            if (already_exists_other_type) {
                throw ddl::dd::Error(
                    _validation_info + "::create",
                    {type_to_add.getName()},
                    std::string("value with the given name already exists with another type of ") +
                        detail::TypeValidationInfo<DDL_TYPE_TO_ACCESS>::_other_types);
            }
        }
        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());
        }
        return new_type_value;
    }

    void emplace(DDL_TYPE_TO_ACCESS&& type_to_add)
    {
        create(std::move(type_to_add));
    }

    void remove(const std::string& type_name)
    {
        auto removed_value = access(type_name);
        if (removed_value) {
            if (_validator) {
                _validator->notifyChangedMapContent(
                    TypeAccessMapEventCode::map_item_removing, *removed_value, type_name);
            }
            _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) {
                // we ask the validator if it already exists
                // this will check if the name might be unique with corresponding
                // other maps ... this functionality is only possible with map! not with lists!
                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 utility {
    using ::ddl::dd::utility::TypeAccessMapEventCode;
    using ::ddl::dd::utility::TypeAccessMapObserver;
    using ::ddl::dd::utility::TypeAccessMapSubject;
    using ::ddl::dd::utility::TypeAccessMap;
} // namespace utility
} // namespace ddl
 
#endif // DD_DD_ACCESS_MAP_H_INCLUDED