container.hxx

#pragma once
 
#include <StormByte/config/exception.hxx>
#include <StormByte/config/item/base.hxx>
#include <StormByte/config/type.hxx>
 
#include <queue>
#include <span>
#include <vector>
 
namespace StormByte::Config::Item {
    class STORMBYTE_CONFIG_PUBLIC Container: public Base {
        public:
            Container()                                         = default;
 
            Container(const std::string& name);
 
            Container(std::string&& name);
 
            Container(const Container& base)                    = default;
 
            Container(Container&& base) noexcept                = default;
 
            Container& operator=(const Container& base)         = default;
 
            Container& operator=(Container&& base) noexcept     = default;
 
            virtual ~Container() noexcept override              = default;
 
            Base&                                               operator[](const size_t& index);
 
            const Base&                                         operator[](const size_t& index) const;
 
            Base&                                               operator[](const std::string& path);
 
            inline const Base&                                  operator[](const std::string& path) const {
                return LookUp(path);
            }
 
            bool                                                operator==(const Container& container) const noexcept;
 
            inline bool                                         operator!=(const Container& container) const noexcept {
                return !operator==(container);
            }
 
            inline Base&                                        Add(const Base& item, const OnExistingAction& on_existing = OnExistingAction::ThrowException) {
                return Add(std::move(*item.Clone()), on_existing);
            }
 
            inline Base&                                        Add(Base&& item, const OnExistingAction& on_existing = OnExistingAction::ThrowException) {
                return Add(item.Move(), on_existing);
            }
 
            Base& Add(Base::PointerType item, const OnExistingAction& on_existing);
 
            inline void                                         Clear() noexcept {
                m_items.clear();
            }
 
            bool                                                Exists(const std::string& path) const;
 
            void                                                Remove(const size_t& index);
 
            void                                                Remove(const std::string& path);
 
            std::string                                         Serialize(const int& indent_level) const noexcept override;
 
            static constexpr std::pair<const char, const char>  EnclosureCharacters(const ContainerType& type) noexcept {
                switch(type) {
                    case ContainerType::Group:  return std::make_pair<const char, const char>('{', '}');
                    case ContainerType::List:   return std::make_pair<const char, const char>('[', ']');
                    default:                    return std::make_pair<const char, const char>('\0', '\0');
                }
            }
 
            static constexpr const char                         EndCharacter(const ContainerType& type) noexcept {
                switch(type) {
                    case ContainerType::Group:  return '}';
                    case ContainerType::List:   return ']';
                    default:                    return '\0';
                }
            }
 
            constexpr std::span<Base::PointerType>              Items() noexcept {
                return std::span(m_items);
            }
 
            constexpr std::span<const Base::PointerType>        Items() const noexcept {
                return std::span(m_items);
            }
 
            constexpr virtual Item::ContainerType               ContainerType() const noexcept = 0;
 
            constexpr std::string                               ContainerTypeToString() const noexcept {
                return Item::TypeToString(this->ContainerType());
            }
 
            constexpr Item::Type                                Type() const noexcept override {
                return Item::Type::Container;
            }
 
            constexpr size_t                                    Size() const noexcept {
                return m_items.size();
            }
 
            size_t                                              Count() const noexcept;
 
        protected:
            std::vector<Base::PointerType>                      m_items;    
 
            virtual Base::PointerType                           BeforeAdditionActions(Base::PointerType item, const OnExistingAction onexisting) = 0;
 
        private:
            virtual std::string                                 ContentsToString(const int& level) const noexcept;
 
            static bool                                         IsPathValid(const std::string& name) noexcept;
 
            const Base&                                         LookUp(const std::string& path) const;
 
            const Base&                                         LookUp(std::queue<std::string>& path) const;
 
            void                                                Remove(std::queue<std::string>& path);
    };
}