access_vector.h

Go to the documentation of this file.

 
#ifndef DD__UTILITY_ACCESS_VECTOR_H_INCLUDED
#define DD__UTILITY_ACCESS_VECTOR_H_INCLUDED
 
#include <ddl/utilities/access_observer.h>
#include <ddl/utilities/ddl_error.h>
 
#include <algorithm>
#include <memory>
 
namespace ddl {
namespace utility {
enum TypeAccessVectorEventCode {
    vector_item_added,
    vector_item_removed,
    vector_item_changed,
    vector_item_renamed,
    vector_subitem_added,
    vector_subitem_removed,
    vector_subitem_changed,
    vector_item_popped,
    vector_subitem_popped,
    vector_item_inserted,
    vector_subitem_inserted,
    vector_subitem_renamed,
    vector_item_removing,
    vector_subitem_removing,
    vector_item_renaming,
    vector_subitem_renaming
};

template <typename T>
using TypeAccessVectorSubject = ModelSubjectUtility<T, TypeAccessVectorEventCode>;

template <typename T>
using TypeAccessVectorObserver = ModelObserverUtility<T, TypeAccessVectorEventCode>;

template <typename DDL_TYPE_TO_ACCESS, typename TYPE_VALIDATOR_CLASS>
class TypeAccessVector : public TypeAccessVectorObserver<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 typename container_type::iterator iterator;
    typedef typename container_type::const_iterator const_iterator;
    typedef TypeAccessVectorObserver<DDL_TYPE_TO_ACCESS> parent_type;
    typedef TypeAccessVectorSubject<DDL_TYPE_TO_ACCESS> observer_subject_type;
    typedef typename observer_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:
    TypeAccessVector() = delete;
    TypeAccessVector(TYPE_VALIDATOR_CLASS* validator, const std::string& validation_info)
        : _validator(validator), _validation_info(validation_info)
    {
    }

    virtual ~TypeAccessVector()
    {
        clear();
    }

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

    TypeAccessVector& operator=(TypeAccessVector&& 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<observer_subject_type*>(current.get()))
                ->detachObserver(static_cast<observer_type*>(&other));
            // i want to observe this
            (static_cast<observer_subject_type*>(current.get()))
                ->attachObserver(static_cast<observer_type*>(this));
        }
        return *this;
    }

    TypeAccessVector(const TypeAccessVector& 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<observer_subject_type*>(new_type.get()))
                ->attachObserver(static_cast<observer_type*>(this));
            _types.push_back(new_type);
        }
    }

    TypeAccessVector& operator=(const TypeAccessVector& 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<observer_subject_type*>(new_type.get()))
                ->attachObserver(static_cast<observer_type*>(this));
            _types.push_back(new_type);
        }
        return *this;
    }
 
public:
    std::shared_ptr<const DDL_TYPE_TO_ACCESS> get(size_t index) const
    {
        if (_types.size() > index) {
            std::shared_ptr<const DDL_TYPE_TO_ACCESS> const_return = _types[index];
            return const_return;
        }
        return {};
    }

    void add(const DDL_TYPE_TO_ACCESS& type_to_add)
    {
        auto new_type_value = std::make_shared<DDL_TYPE_TO_ACCESS>(type_to_add);
        // i want to observe this
        (static_cast<observer_subject_type*>(new_type_value.get()))
            ->attachObserver(static_cast<observer_type*>(this));
        _types.push_back(new_type_value);
 
        if (_validator) {
            _validator->notifyChangedVectorContent(TypeAccessVectorEventCode::vector_item_added,
                                                   *new_type_value,
                                                   std::to_string(_types.size() - 1));
        }
    }

    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 {
            auto new_type_value = std::make_shared<DDL_TYPE_TO_ACCESS>(type_to_add);
            // i want to observe this
            (static_cast<observer_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) {
                _validator->notifyChangedVectorContent(
                    TypeAccessVectorEventCode::vector_item_inserted,
                    *new_type_value,
                    std::to_string(pos_idx));
            }
        }
    }

    void emplace(DDL_TYPE_TO_ACCESS&& type_to_add)
    {
        auto new_type_value = std::make_shared<DDL_TYPE_TO_ACCESS>(std::move(type_to_add));
        // i want to observe this
        (static_cast<observer_subject_type*>(new_type_value.get()))
            ->attachObserver(static_cast<observer_type*>(this));
        _types.push_back(new_type_value);
        if (_validator) {
            _validator->notifyChangedVectorContent(TypeAccessVectorEventCode::vector_item_added,
                                                   *new_type_value,
                                                   std::to_string(_types.size() - 1));
        }
    }

    void remove(size_t index)
    {
        if (_types.size() > index) {
            value_type removed_value;
            typename container_type::iterator current_it = begin();
            std::advance(current_it, index);
            removed_value = *current_it;
            if (removed_value) {
                if (_validator) {
                    _validator->notifyChangedVectorContent(
                        TypeAccessVectorEventCode::vector_item_removing,
                        *removed_value,
                        std::to_string(index));
                }
                _types.erase(current_it);
                (static_cast<subject_type*>(removed_value.get()))
                    ->detachObserver(static_cast<observer_type*>(this));
                if (_validator) {
                    _validator->notifyChangedVectorContent(
                        TypeAccessVectorEventCode::vector_item_removed,
                        *removed_value,
                        std::to_string(index));
                }
                return;
            }
        }
        throw ddl::dd::Error(_validation_info + "::remove",
                             {std::to_string(index)},
                             "value with the index does not exist");
    }

    std::shared_ptr<DDL_TYPE_TO_ACCESS> access(size_t index)
    {
        if (index < _types.size()) {
            return _types[index];
        }
        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 TypeAccessVector& other) const
    {
        return std::equal(
            begin(), end(), other.begin(), other.end(), [](const auto& local, const auto& other) {
                return *(local) == *(other);
            });
    }

    bool operator!=(const TypeAccessVector& 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));
        }
        _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));
            _types.pop_back();
            if (_validator) {
                _validator->notifyChangedVectorContent(
                    TypeAccessVectorEventCode::vector_item_popped, *last_element, "-1");
            }
        }
        else {
            throw ddl::dd::Error(_validation_info + "::popBack", {}, "vector is empty");
        }
    }
 
public:
    void modelChanged(event_code_type event_code,
                      subject_type& subject_changed,
                      const std::string& additional_info)
    {
        if (_validator) {
            // i should discover the shared_ptr here, but not needed at the moment
            _validator->notifyChangedVectorContent(event_code, subject_changed, additional_info);
        }
    }
 
private:
    void deepCopy(TypeAccessVector& destination, TYPE_VALIDATOR_CLASS* validator) const
    {
        destination = *this;
        destination.setValidator(validator);
    }
 
    void setValidator(TYPE_VALIDATOR_CLASS* validator)
    {
        _validator = validator;
    }
 
    container_type _types;
    TYPE_VALIDATOR_CLASS* _validator = {};
    std::string _validation_info;
};
 
} // namespace utility
} // namespace ddl
 
#endif // DD__UTILITY_ACCESS_VECTOR_H_INCLUDED