access_list.h

Go to the documentation of this file.

 
#ifndef DDL_UTILITY_ACCESS_LIST_H_INCLUDED
#define DDL_UTILITY_ACCESS_LIST_H_INCLUDED
 
#include <ddl/utilities/access_observer.h>
#include <ddl/utilities/access_optional.h>
#include <ddl/utilities/access_validation.h>
#include <ddl/utilities/ddl_error.h>
 
#include <algorithm>
#include <memory>
#include <unordered_map>
#include <string_view>
 
namespace ddl {
namespace utility {
    // forward declaration
    template <typename DDL_TYPE_TO_ACCESS, typename TYPE_VALIDATOR_CLASS>
    class TypeAccessList;
}
namespace dd {
namespace utility {
enum TypeAccessListEventCode {
    list_item_added,
    list_item_removed,
    list_item_changed,
    list_item_renamed,
    list_subitem_added,
    list_subitem_removed,
    list_subitem_changed,
    list_item_popped,
    list_subitem_popped,
    list_item_inserted,
    list_subitem_inserted,
    list_subitem_renamed,
    list_item_removing,
    list_subitem_removing,
    list_item_renaming,
    list_subitem_renaming
};

template <typename T>
using TypeAccessListSubject = ModelSubjectUtility<T, TypeAccessListEventCode>;

template <typename T>
using TypeAccessListObserver = ModelObserverUtility<T, TypeAccessListEventCode>;

template <typename DDL_TYPE_TO_ACCESS, typename TYPE_VALIDATOR_CLASS>
class TypeAccessList : public TypeAccessListObserver<DDL_TYPE_TO_ACCESS> {
public:
    typedef DDL_TYPE_TO_ACCESS access_type;
    typedef std::shared_ptr<DDL_TYPE_TO_ACCESS> value_type;
    typedef std::vector<value_type> container_type;
    typedef std::unordered_map<std::string_view, value_type> container_named_type;
    typedef typename container_type::iterator iterator;
    typedef typename container_type::const_iterator const_iterator;
    typedef TypeAccessListObserver<DDL_TYPE_TO_ACCESS> parent_type;
    typedef TypeAccessListSubject<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:
    TypeAccessList() = delete;
    TypeAccessList(TYPE_VALIDATOR_CLASS* validator, const std::string& validation_info)
        : _validator(validator), _validation_info(validation_info)
    {
    }

    virtual ~TypeAccessList()
    {
        clear();
    }

    TypeAccessList(TypeAccessList&& other)
    {
        *this = std::move(other);
    }

    TypeAccessList& operator=(TypeAccessList&& other)
    {
        clear();
        _validation_info = std::move(other._validation_info);
        _types = std::move(other._types);
        // the other will not observe this anymore after this clear
        for (const auto& current: _types) {
            // the other will not observe this anymore
            (static_cast<map_subject_type*>(current.get()))
                ->detachObserver(static_cast<observer_type*>(&other));
            // i want to observe this
            (static_cast<map_subject_type*>(current.get()))
                ->attachObserver(static_cast<observer_type*>(this));
        }
        return *this;
    }

    TypeAccessList(const TypeAccessList& other)
        : _validator(nullptr), _validation_info(other._validation_info)
    {
        for (auto current: other._types) {
            auto new_type = std::make_shared<DDL_TYPE_TO_ACCESS>(*current);
            // i want to observe this
            (static_cast<map_subject_type*>(new_type.get()))
                ->attachObserver(static_cast<observer_type*>(this));
            _types.push_back(new_type);
        }
    }

    TypeAccessList& operator=(const TypeAccessList& other)
    {
        clear();
        _validation_info = other._validation_info;
        for (auto current: other._types) {
            auto new_type = std::make_shared<DDL_TYPE_TO_ACCESS>(*current);
            // i want to observe this
            (static_cast<map_subject_type*>(new_type.get()))
                ->attachObserver(static_cast<observer_type*>(this));
            _types.push_back(new_type);
        }
        _validator = nullptr;
        return *this;
    }
 
public:
    std::shared_ptr<const DDL_TYPE_TO_ACCESS> get(std::string_view type_name) const
    {
        if (_validator) {
            const auto named_items = getNamedContainer();
            const auto found = named_items->find(type_name);
            if (found != named_items->end()) {
                return found->second;
            }
        }
        else {
            for (auto& current: _types) {
                if (current->getName() == type_name) {
                    std::shared_ptr<const DDL_TYPE_TO_ACCESS> const_return = current;
                    return const_return;
                }
            }
        }
        return {};
    }

    Optional<size_t> getPosOf(const std::string& type_name) const
    {
        size_t current_pos = 0;
        for (auto& current: _types) {
            if (current->getName() == type_name) {
                return current_pos;
            }
            ++current_pos;
        }
 
        return {};
    }

    bool contains(const std::string& type_name) const
    {
        if (_validator) {
            const auto named_items = getNamedContainer();
            const auto found = named_items->find(type_name);
            if (found != named_items->end()) {
                return true;
            }
        }
        else {
            for (auto& current: _types) {
                if (current->getName() == type_name) {
                    return true;
                }
            }
        }
        return false;
    }

    bool contains(const DDL_TYPE_TO_ACCESS& type_to_find) const
    {
        const auto value_found = get(type_to_find.getName());
        if (value_found) {
            return type_to_find == *value_found;
        }
        return false;
    }

    bool contains(const TypeAccessList& other) const
    {
        for (const auto& other_content: other._types) {
            if (!contains(*other_content)) {
                return false;
            }
        }
        return true;
    }

    std::shared_ptr<DDL_TYPE_TO_ACCESS> create(const DDL_TYPE_TO_ACCESS& type_to_add)
    {
        if (checkExistenceAndEquality(type_to_add)) {
            // this will immediatelly return if the type exists and is equal
            // otherwise the check will throw!
            return access(type_to_add.getName());
        }
 
        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.push_back(new_type_value);
        if (_validator) {
            const auto named_items = getNamedContainer();
            (*named_items)[new_type_value->getName()] = new_type_value;
        }
        if (_validator) {
            _validator->notifyChangedListContent(
                TypeAccessListEventCode::list_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);
    }

    void insert(const size_t pos_idx, const DDL_TYPE_TO_ACCESS& type_to_add)
    {
        if (pos_idx > getSize()) {
            throw ddl::dd::Error(
                _validation_info + "::insert", {type_to_add.getName()}, "given pos_idx is invalid");
        }
        else if (pos_idx == getSize()) {
            add(type_to_add);
        }
        else {
            if (checkExistenceAndEquality(type_to_add)) {
                // this will immediatelly return if the type exists and is equal
                // otherwise the check will throw!
                return;
            }
            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));
 
            auto cit = cbegin();
            std::advance(cit, pos_idx);
            _types.insert(cit, new_type_value);
            if (_validator) {
                const auto named_items = getNamedContainer();
                (*named_items)[new_type_value->getName()] = new_type_value;
            }
            if (_validator) {
                _validator->notifyChangedListContent(TypeAccessListEventCode::list_item_inserted,
                                                     *new_type_value,
                                                     type_to_add.getName());
            }
        }
    }

    std::shared_ptr<DDL_TYPE_TO_ACCESS> create(DDL_TYPE_TO_ACCESS&& type_to_add)
    {
        if (checkExistenceAndEquality(type_to_add)) {
            // this will immediatelly return if the type exists and is equal
            // otherwise the check will throw!
            return access(type_to_add.getName());
        }
        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.push_back(new_type_value);
        if (_validator) {
            const auto named_items = getNamedContainer();
            (*named_items)[new_type_value->getName()] = new_type_value;
        }
        if (_validator) {
            _validator->notifyChangedListContent(TypeAccessListEventCode::list_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)
    {
        value_type removed_value;
        typename container_type::iterator current_it;
        for (current_it = _types.begin(); current_it != _types.end(); ++current_it) {
            if ((*current_it)->getName() == type_name) {
                removed_value = (*current_it);
                break;
            }
        }
        if (removed_value) {
            if (_validator) {
                _validator->notifyChangedListContent(
                    TypeAccessListEventCode::list_item_removing, *removed_value, type_name);
            }
            _types.erase(current_it);
            if (_validator) {
                const auto named_items = getNamedContainer();
                named_items->erase(type_name);
            }
            (static_cast<subject_type*>(removed_value.get()))
                ->detachObserver(static_cast<observer_type*>(this));
            if (_validator) {
                _validator->notifyChangedListContent(
                    TypeAccessListEventCode::list_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)
    {
        if (_validator) {
            const auto named_items = getNamedContainer();
            auto value_found = named_items->find(type_name);
            if (value_found != named_items->end()) {
                return value_found->second;
            }
        }
        else {
            for (const auto& current: _types) {
                if (current->getName() == type_name) {
                    return current;
                }
            }
        }
        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 TypeAccessList& other) const
    {
        return std::equal(
            begin(), end(), other.begin(), other.end(), [](const auto& local, const auto& other) {
                return *(local) == *(other);
            });
    }

    bool operator!=(const TypeAccessList& other) const
    {
        return !operator==(other);
    }

    void clear()
    {
        for (auto& current: _types) {
            // unregister me as observer
            (static_cast<subject_type*>(current.get()))
                ->detachObserver(static_cast<observer_type*>(this));
        }
        if (_validator) {
            const auto named_items = getNamedContainer();
            named_items->clear();
        }
        _types.clear();
    }

    void popBack()
    {
        if (!_types.empty()) {
            auto last_element = _types[_types.size() - 1];
            if (_validator) {
                _validator->notifyChangedListContent(TypeAccessListEventCode::list_item_removing,
                                                     *last_element,
                                                     last_element->getName());
            }
            // unregister me as observer
            (static_cast<subject_type*>(last_element.get()))
                ->detachObserver(static_cast<observer_type*>(this));
            // pop last element
            if (_validator) {
                const auto named_items = getNamedContainer();
                named_items->erase(last_element->getName());
            }
            _types.pop_back();
            if (_validator) {
                _validator->notifyChangedListContent(TypeAccessListEventCode::list_item_popped,
                                                     *last_element,
                                                     last_element->getName());
            }
        }
        else {
            throw ddl::dd::Error(_validation_info + "::popBack", {}, "list is empty");
        }
    }
 
public:
    void modelChanged(event_code_type event_code,
                      subject_type& subject_changed,
                      const std::string& additional_info)
    {
        if (event_code == list_item_renaming) {
            // the validator can not be asked for the renaming here, (because of ABI compatibility, the validateContains can not be changed!)
            // if you need to have unique names depending on other data structures use the TypeAccessMap instead of TypeAccessList!
            if (countContains(additional_info) != 0) {
                throw ddl::dd::Error(
                    _validation_info + "::modelChanged",
                    {additional_info},
                    "Renaming not possible. Value with the given name already exists");
            }
            else {
                if (_validator) {
                    const auto named_items = getNamedContainer();
                    // item will be re-added after renaming
                    named_items->erase(subject_changed.getName());
                }
            }
        }
        else if (event_code == list_item_renamed) {
            if (_validator) {
                const auto named_items = getNamedContainer();
                for (auto& current: _types) {
                    if (current->getName() == subject_changed.getName()) {
                        named_items->emplace(current->getName(), current);
                        break;
                    }
                }
            }
        }
        if (_validator) {
            // i should discover the shared_ptr here, but not needed at the moment
            _validator->notifyChangedListContent(event_code, subject_changed, additional_info);
        }
    }
 
private:
    // forward declaration
    friend class ::ddl::utility::TypeAccessList<DDL_TYPE_TO_ACCESS,
                                                TYPE_VALIDATOR_CLASS>;
    void deepCopy(TypeAccessList& destination, TYPE_VALIDATOR_CLASS* validator) const
    {
        destination = *this;
        destination.setValidator(validator);
    }
    size_t countContains(const std::string& type_name) const
    {
        return std::count_if(_types.begin(), _types.end(), [type_name](const value_type& value) {
            return value->getName() == type_name;
        });
    }
 
    bool checkExistenceAndEquality(const DDL_TYPE_TO_ACCESS& type_to_add)
    {
        // has already another type
        bool already_exists = false;
        if (_validator) {
            already_exists = _validator->validateContains(type_to_add);
        }
        else {
            already_exists = contains(type_to_add.getName());
        }
        if (already_exists) {
            // have a look if the type does exist in this list
            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) {
                    // its okay ... its the same type/content
                    return true;
                }
                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));
            }
            else {
                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);
            }
        }
        return false;
    }
 
    void setValidator(TYPE_VALIDATOR_CLASS* validator)
    {
        _validator = validator;
        if (_validator) {
            auto named_items = getNamedContainer();
            named_items->clear();
            for (auto& value: _types) {
                (*named_items)[value->getName()] = value;
            }
        }
    }
 
    const container_named_type* getNamedContainer() const
    {
        // getNamedItemList is dead, but it must be implemented within the _validator for
        // binary compatibility reason
        return _validator->getNamedItemViewList();
    }
 
    container_named_type* getNamedContainer()
    {
        // getNamedItemList is dead, but it must be implemented within the _validator for
        // binary compatibility reason
        return _validator->getNamedItemViewList();
    }
 
    container_type _types;
    TYPE_VALIDATOR_CLASS* _validator = {};
    std::string _validation_info;
};
 
} // namespace utility
} // namespace dd
 
namespace utility {
 
// (usually these enums and templates should be moved to utility namespace, but we stay binary
// compatible for now!)
using ::ddl::dd::utility::TypeAccessListEventCode;

template <typename T>
using TypeAccessListSubject = ModelSubjectUtility<T, TypeAccessListEventCode>;

template <typename T>
using TypeAccessListObserver = ModelObserverUtility<T, TypeAccessListEventCode>;

template <typename DDL_TYPE_TO_ACCESS, typename TYPE_VALIDATOR_CLASS>
class TypeAccessList
    : public ::ddl::dd::utility::TypeAccessList<
          DDL_TYPE_TO_ACCESS,
          ::ddl::utility::TypeAccessList<DDL_TYPE_TO_ACCESS, TYPE_VALIDATOR_CLASS>> {
public:
    using base_type = ::ddl::dd::utility::TypeAccessList<
        DDL_TYPE_TO_ACCESS,
        ::ddl::utility::TypeAccessList<DDL_TYPE_TO_ACCESS, TYPE_VALIDATOR_CLASS>>;
    friend TYPE_VALIDATOR_CLASS;
    friend base_type;

    TypeAccessList() = delete;
    TypeAccessList(TYPE_VALIDATOR_CLASS* validator, const std::string& validation_info)
        : base_type(this, validation_info), _validator(validator)
    {
    }

    virtual ~TypeAccessList()
    {
        base_type::_validator = {};
    }

    TypeAccessList(TypeAccessList&& other) = default;
    TypeAccessList& operator=(TypeAccessList&& other) = default;

    TypeAccessList(const TypeAccessList& other) : base_type(this, other._validation_info)
    {
        other.deepCopy(*this, this);
        for (auto& current: *this) {
            _named_types[current->getName()] = current;
        }
    }

    TypeAccessList& operator=(const TypeAccessList& other)
    {
        other.deepCopy(*this, this);
        for (auto& current: *this) {
            _named_types[current->getName()] = current;
        }
        return *this;
    }
 
private:
    bool validateContains(const typename base_type::access_type& subject) const
    {
        if (_validator) {
            return _validator->validateContains(subject);
        }
        return false;
    }
 
    void notifyChangedListContent(typename base_type::event_code_type code,
                                  typename base_type::access_type& subject,
                                  const std::string& additional_info)
    {
        if (_validator) {
            return _validator->notifyChangedListContent(code, subject, additional_info);
        }
    }
 
    const typename base_type::container_named_type* getNamedItemViewList() const
    {
        return &_named_types;
    }
 
    typename base_type::container_named_type* getNamedItemViewList()
    {
        return &_named_types;
    }
 
private:
    typename base_type::container_named_type _named_types;
    TYPE_VALIDATOR_CLASS* _validator = {};
};
 
} // namespace utility
} // namespace ddl
 
#endif // DDL_UTILITY_ACCESS_LIST_H_INCLUDED