DAGenericIndexedContainer.hpp

#ifndef DAGENERICINDEXEDCONTAINER_H
#define DAGENERICINDEXEDCONTAINER_H
 
#include <type_traits>
#include <utility>
#include <stdexcept>
namespace DA
{
 
template< typename Container,
          typename IndexType = int,
          typename SFINAE_CHECK =
              std::void_t< typename Container::size_type,
                           typename Container::value_type,
                           decltype(std::declval< Container >()[ std::declval< typename Container::size_type >() ]) > >
class DAGenericIndexedContainer
{
public:
    using value_type = typename Container::value_type;
    using reference = typename Container::reference;
    using const_reference = typename Container::const_reference;
    using size_type = typename Container::size_type;
    using iterator               = typename Container::iterator;                
    using const_iterator         = typename Container::const_iterator;          
    using reverse_iterator       = typename Container::reverse_iterator;        
    using const_reverse_iterator = typename Container::const_reverse_iterator;  
 
    enum class IndexPolicy
    {
        AutoReset,
 
        PreserveRaw,
 
        ForceReset
    };
 
public:
 
    DAGenericIndexedContainer() = default;
 
    template< typename... Args >
    explicit DAGenericIndexedContainer(Args&&... args) : m_container(std::forward< Args >(args)...)
    {
    }
 
    DAGenericIndexedContainer(std::initializer_list< value_type > init) : m_container(init)
    {
    }
 
 
    value_type next()
    {
        moveToNext();
        return current();
    }
 
    void moveToNext()
    {
        if (empty())
            return;
        m_index = (m_index + 1) % static_cast< IndexType >(size());
    }
 
    value_type previous()
    {
        moveToPrevious();
        return current();
    }
 
    void moveToPrevious()
    {
        if (empty())
            return;
        m_index = (m_index == 0) ? static_cast< IndexType >(size() - 1) : m_index - 1;
    }
 
    reference current()
    {
        return m_container[ static_cast< size_type >(m_index) ];
    }
 
    const_reference current() const
    {
        return m_container[ static_cast< size_type >(m_index) ];
    }
 
 
    value_type operator++()
    {
        moveToNext();
        return current();
    }
 
    value_type operator++(int)
    {
        value_type tmp = current();
        moveToNext();
        return tmp;
    }
 
    value_type operator--()
    {
        moveToPrevious();
        return current();
    }
 
    value_type operator--(int)
    {
        value_type tmp = current();
        moveToPrevious();
        return tmp;
    }
 
 
    bool empty() const noexcept
    {
        return m_container.empty();
    }
 
    size_type size() const noexcept
    {
        return m_container.size();
    }
 
    void clear()
    {
        m_container.clear();
        m_index = 0;
    }
 
    template< typename... Args >
    void emplace_back(Args&&... args)
    {
        m_container.emplace_back(std::forward< Args >(args)...);
    }
 
 
    reference first()
    {
        return m_container.front();
    }
 
    const_reference first() const
    {
        return m_container.front();
    }
 
    reference last()
    {
        return m_container.back();
    }
 
    const_reference last() const
    {
        return m_container.back();
    }
 
    reference firstChecked()
    {
        if (empty()) {
            throw std::out_of_range("Accessing first element of empty container");
        }
        return m_container.front();
    }
 
    const_reference firstChecked() const
    {
        if (empty()) {
            throw std::out_of_range("Accessing first element of empty container");
        }
        return m_container.front();
    }
 
    reference lastChecked()
    {
        if (empty()) {
            throw std::out_of_range("Accessing last element of empty container");
        }
        return m_container.back();
    }
 
    const_reference lastChecked() const
    {
        if (empty()) {
            throw std::out_of_range("Accessing last element of empty container");
        }
        return m_container.back();
    }
 
 
 
    IndexType currentIndex() const noexcept
    {
        return m_index;
    }
 
    void setCurrentIndex(IndexType index) noexcept
    {
        m_index = index;
    }
 
    bool isValidIndex() const noexcept
    {
        return m_index >= 0 && static_cast< size_type >(m_index) < size();
    }
 
    bool isFirstIndex() const
    {
        return m_index == 0 || m_container.empty();
    }
 
    bool isLastIndex() const
    {
        return (!m_container.empty()) && (m_index == m_container.size() - 1);
    }
 
 
 
    DAGenericIndexedContainer& operator=(const Container& other)
    {
 
        // 拷贝前保存原索引
        const size_type oldIndex = static_cast< size_type >(m_index);
 
        // 执行容器拷贝
        m_container = other;
 
        // 调整索引
        if (!m_container.empty()) {
            // 新容器非空时调整索引
            if (oldIndex < m_container.size()) {
                m_index = static_cast< IndexType >(oldIndex);
            } else {
                m_index = 0;
            }
        } else {
            // 新容器为空时保持索引0（无效状态）
            m_index = 0;
        }
 
        return *this;
    }
 
    DAGenericIndexedContainer& operator=(Container&& other) noexcept
    {
        // 移动前保存原索引
        const size_type oldIndex = static_cast< size_type >(m_index);
 
        // 执行容器移动
        m_container = std::move(other);
 
        // 调整索引（逻辑同拷贝版本）
        if (!m_container.empty()) {
            m_index = (oldIndex < m_container.size()) ? static_cast< IndexType >(oldIndex) : 0;
        } else {
            m_index = 0;
        }
        return *this;
    }
 
 
 
    void replace(Container newContainer, IndexPolicy policy = IndexPolicy::AutoReset)
    {
        const size_type oldIndex = static_cast< size_type >(m_index);
 
        m_container = std::move(newContainer);
 
        switch (policy) {
        case IndexPolicy::AutoReset:
            if (!m_container.empty()) {
                m_index = (oldIndex < m_container.size()) ? static_cast< IndexType >(oldIndex) : 0;
            } else {
                m_index = 0;
            }
            break;
        case IndexPolicy::PreserveRaw:
            // 不调整，可能无效
            break;
        case IndexPolicy::ForceReset:
            m_index = 0;
            break;
        }
    }
 
 
    reference operator[](IndexType index)
    {
        return m_container[ static_cast< size_type >(index) ];
    }
 
    const_reference operator[](IndexType index) const
    {
        return m_container[ static_cast< size_type >(index) ];
    }
 
 
 
    reference at(IndexType index)
    {
        const size_type idx = static_cast< size_type >(index);
        if (idx >= size()) {
            throw std::out_of_range("Index out of range");
        }
        return m_container[ idx ];
    }
 
    const_reference at(IndexType index) const
    {
        const size_type idx = static_cast< size_type >(index);
        if (idx >= size()) {
            throw std::out_of_range("Index out of range");
        }
        return m_container[ idx ];
    }
 
 
    iterator begin() noexcept
    {
        return m_container.begin();
    }
 
    iterator end() noexcept
    {
        return m_container.end();
    }
 
    const_iterator begin() const noexcept
    {
        return m_container.begin();
    }
 
    const_iterator end() const noexcept
    {
        return m_container.end();
    }
 
    const_iterator cbegin() const noexcept
    {
        return m_container.cbegin();
    }
 
    const_iterator cend() const noexcept
    {
        return m_container.cend();
    }
 
    reverse_iterator rbegin() noexcept
    {
        return m_container.rbegin();
    }
 
    reverse_iterator rend() noexcept
    {
        return m_container.rend();
    }
 
    const_reverse_iterator crbegin() const noexcept
    {
        return m_container.crbegin();
    }
 
    const_reverse_iterator crend() const noexcept
    {
        return m_container.crend();
    }
 
    const Container& container() const
    {
        return m_container;
    }
 
private:
    Container m_container;  
    IndexType m_index = 0;  
};
 
}  // namespace DA
 
#endif  // DAGENERICINDEXEDCONTAINER_H