ArrayView.hpp

#pragma once
 
#include "util/Assert.hpp"
#include "util/config/ConfigDefinition.hpp"
#include "util/config/ObjectView.hpp"
#include "util/config/ValueView.hpp"
 
#include <cstddef>
#include <functional>
#include <iterator>
#include <string>
#include <string_view>
 
namespace util::config {

class ArrayView {
public:
    template <typename T>
    struct ArrayIterator {
        using iterator_category = std::forward_iterator_tag;
        using pointer = T const*;
        using reference = T const&;
        using value_type = T;

        ArrayIterator(ArrayView const& arr, std::size_t index) : arr_{arr}, index_{index}
        {
            if (arr_.clioConfig_.get().contains(arr_.prefix_)) {
                ASSERT((std::is_same_v<T, ValueView>), "Array iterator must be ValueView");
            } else {
                ASSERT((std::is_same_v<T, ObjectView>), "Array iterator must be ObjectView");
            }
        }

        ArrayIterator&
        operator++()
        {
            if (index_ < arr_.size())
                ++index_;
            return *this;
        }

        ArrayIterator
        operator++(int)
        {
            ArrayIterator temp = *this;
            if (index_ < arr_.size())
                ++index_;
            return temp;
        }

        T
        operator*()
        {
            if constexpr (std::is_same_v<T, ObjectView>) {
                return ObjectView{arr_.prefix_, index_, arr_.clioConfig_.get()};
            } else {
                return arr_.clioConfig_.get().getValueInArray(arr_.prefix_, index_);
            }
        }

        bool
        operator==(ArrayIterator const& other) const
        {
            return &arr_ == &(other.arr_) && index_ == other.index_;
        }

        bool
        operator!=(ArrayIterator const& other) const
        {
            return &arr_ != &(other.arr_) || index_ != other.index_;
        }
 
    private:
        ArrayView const& arr_;
        std::size_t index_ = 0;
    };

    template <typename T>
    [[nodiscard]] auto
    begin() const
    {
        return ArrayIterator<T>(*this, 0);
    }

    template <typename T>
    [[nodiscard]] auto
    end() const
    {
        return ArrayIterator<T>(*this, this->size());
    }

    ArrayView(std::string_view prefix, ClioConfigDefinition const& configDef);

    [[nodiscard]] ObjectView
    objectAt(std::size_t idx) const;

    [[nodiscard]] ValueView
    valueAt(std::size_t idx) const;

    [[nodiscard]] size_t
    size() const;
 
private:
    std::string prefix_;
    std::reference_wrapper<ClioConfigDefinition const> clioConfig_;
};
 
}  // namespace util::config