DataList.h

Go to the documentation of this file.

 
#ifndef LLU_CONTAINERS_DATALIST_H
#define LLU_CONTAINERS_DATALIST_H
 
#include <initializer_list>
#include <string>
#include <string_view>
#include <utility>
#include <vector>
 
#include "LLU/Containers/Generic/DataStore.hpp"
#include "LLU/Containers/Iterators/DataList.hpp"
#include "LLU/ErrorLog/ErrorManager.h"
#include "LLU/LibraryData.h"
#include "LLU/MArgument.h"
#include "LLU/TypedMArgument.h"
 
namespace LLU {
 
    namespace NodeType = Argument::Typed;
 
    template<typename T>
    class DataList : public MContainer<MArgumentType::DataStore> {
    public:
        using iterator = NodeIterator<T>;
 
        using const_iterator = iterator;
 
        using value_iterator = NodeValueIterator<T>;
 
        using name_iterator = NodeNameIterator;
 
        using value_type = T;
 
    public:
        using GenericDataList::GenericDataList; // NOLINT(modernize-use-equals-default): false positive
 
        explicit DataList(GenericDataList gds);
 
        DataList(std::initializer_list<value_type> initList);
 
        DataList(std::initializer_list<std::pair<std::string, value_type>> initList);
 
        [[nodiscard]] DataList clone() const;
 
        iterator begin() const {
            return iterator {front()};
        }
 
        const_iterator cbegin() const {
            return const_iterator {begin()};
        }
 
        iterator end() const {
            return iterator {nullptr};
        }
 
        const_iterator cend() const {
            return const_iterator {end()};
        }
 
        value_iterator valueBegin() const {
            return value_iterator {front()};
        }
 
        value_iterator valueEnd() const {
            return value_iterator {nullptr};
        }
 
        name_iterator nameBegin() const {
            return name_iterator {front()};
        }
 
        name_iterator nameEnd() const {
            return name_iterator {nullptr};
        }
 
        void push_back(value_type nodeData);
 
        void push_back(std::string_view name, value_type nodeData);
 
        std::vector<T> values() const {
            return {valueBegin(), valueEnd()};
        }
 
        std::vector<std::string> names() const {
            return {nameBegin(), nameEnd()};
        }
 
        std::vector<DataNode<T>> toVector() const {
            return {cbegin(), cend()};
        }
    };
 
    /* Definitions od DataList methods */
 
    template<typename T>
    DataList<T>::DataList(GenericDataList gds) : GenericDataList(std::move(gds)) {
        if constexpr (!std::is_same_v<T, LLU::NodeType::Any>) {
            std::for_each(GenericDataList::cbegin(), GenericDataList::cend(), [](auto node) {
                if (node.type() != Argument::WrapperIndex<T>) {
                    ErrorManager::throwException(ErrorName::DLInvalidNodeType);
                }
            });
        }
    }
 
    template<typename T>
    DataList<T>::DataList(std::initializer_list<value_type> initList) : DataList() {
        for (auto&& elem : initList) {
            push_back(std::move(elem));
        }
    }
 
    template<typename T>
    DataList<T>::DataList(std::initializer_list<std::pair<std::string, value_type>> initList) : DataList() {
        for (auto&& elem : initList) {
            push_back(elem.first, std::move(elem.second));
        }
    }
 
    template<typename T>
    DataList<T> DataList<T>::clone() const {
        return DataList {cloneContainer(), Ownership::Library};
    }
 
    template<typename T>
    void DataList<T>::push_back(value_type nodeData) {
        GenericDataList::push_back(std::move(nodeData));
    }
 
    template<typename T>
    void DataList<T>::push_back(std::string_view name, value_type nodeData) {
        GenericDataList::push_back(name, std::move(nodeData));
    }
 
 
    namespace Detail {
        template<typename T, typename IteratorType>
        struct IteratorAdaptor {
            using iterator = IteratorType;
 
            explicit IteratorAdaptor(DataList<T>& d) : dl {d} {};
 
            iterator begin() const {
                return iterator {dl.begin()};
            }
 
            iterator cbegin() {
                return iterator {dl.begin()};
            }
 
            iterator end() const {
                return iterator {dl.end()};
            }
 
            iterator end() {
                return iterator {dl.end()};
            }
 
        private:
            DataList<T>& dl;
        };
    }  // namespace Detail
 
    template<typename T>
    struct ValueAdaptor : Detail::IteratorAdaptor<T, NodeValueIterator<T>> {
        explicit ValueAdaptor(DataList<T>& d) : Detail::IteratorAdaptor<T, NodeValueIterator<T>> {d} {};
    };
 
    template<typename T>
    struct NameAdaptor : Detail::IteratorAdaptor<T, NodeNameIterator> {
        explicit NameAdaptor(DataList<T>& d) : Detail::IteratorAdaptor<T, NodeNameIterator> {d} {};
    };
 
}  // namespace LLU
 
#endif    // LLU_CONTAINERS_DATALIST_H