dd_access_list.h

Go to the documentation of this file.

 
#ifndef DD_DD_ACCESS_LIST_H_INCLUDED
#define DD_DD_ACCESS_LIST_H_INCLUDED
 
#include <a_util/base/feature_check/library/string_view.h>
#include <ddl/dd/dd_common_types.h>
#include <ddl/dd/dd_error.h>
#include <ddl/utilities/dd_access_observer.h>
 
#include <algorithm>
#include <memory>
#include <unordered_map>
#if HAS_STRING_VIEW
#include <string_view>
#endif // HAS_STRING_VIEW
 
namespace ddl {
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
};
 
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;
#if HAS_STRING_VIEW
    typedef std::unordered_map<std::string_view, value_type> container_named_type;
    #ifndef dev_essential_TYPE_ACCESS_LIST_COMPATIBILITY
        #if defined(__GNUC__) && (__GNUC__ > 7)
            #define dev_essential_TYPE_ACCESS_LIST_COMPATIBILITY 0
        #elif defined(_MSC_VER) && (_MSC_VER >= 1920)
            #define dev_essential_TYPE_ACCESS_LIST_COMPATIBILITY 0
        #else
            #define dev_essential_TYPE_ACCESS_LIST_COMPATIBILITY 1
        #endif
    #endif
#else
    typedef std::unordered_map<std::string, value_type> container_named_type;
    #ifndef dev_essential_TYPE_ACCESS_LIST_COMPATIBILITY
        #define dev_essential_TYPE_ACCESS_LIST_COMPATIBILITY 0
    #endif
#endif // HAS_STRING_VIEW
    #if dev_essential_TYPE_ACCESS_LIST_COMPATIBILITY
        typedef std::unordered_map<std::string, value_type> container_named_compatibility_type;
    #else
        #ifdef HAS_STRING_VIEW
            typedef std::unordered_map<std::string_view, value_type> container_named_compatibility_type;
        #else
            typedef std::unordered_map<std::string, value_type> container_named_compatibility_type;
        #endif
    #endif
    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));
        }
        _validator = nullptr;
        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(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 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 {};
    }
 
    OptionalSize 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;
    }
 
    void add(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;
        }
 
        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());
        }
    }
 
    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());
            }
        }
    }
 
    void emplace(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;
        }
        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());
        }
    }
 
    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) {
            _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(), [](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];
            // 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_renamed) {
            bool already_exists = false;
            if (_validator) {
                already_exists = _validator->validateContains(subject_changed);
            }
            else {
                already_exists = countContains(subject_changed.getName()) > 1;
            }
            if (already_exists) {
                throw ddl::dd::Error(
                    _validation_info + "::modelChanged",
                    {subject_changed.getName()},
                    "Renaming not possible. Value with the given name already exists");
            }
            else {
                if (_validator) {
                    const auto named_items = getNamedContainer();
                    auto found_in_names = named_items->begin();
                    for (; found_in_names != named_items->end(); ++found_in_names) {
                        // we need to search it to reset the stringview
                        if (found_in_names->second->getName() == subject_changed.getName()) {
                            auto old_value = found_in_names->second;
                            named_items->erase(found_in_names);
                            (*named_items)[old_value->getName()] = old_value;
                            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:
    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 + "::add",
                                     {type_to_add.getName()},
                                     "value with the given name already exists");
            }
            else {
                throw ddl::dd::Error(_validation_info + "::add",
                                     {type_to_add.getName()},
                                     "value with the given name already exists");
            }
        }
        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 ddl
 
#endif // DD_DD_ACCESS_LIST_H_INCLUDED