tokenList.hpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2023 - 2026 NeoN authors
//
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include "NeoN/core/visibility.hpp"
 
#include <vector>
#include <any>
 
#include "NeoN/core/demangle.hpp"
 
namespace NeoN
{
 
 
void logOutRange(
    const std::out_of_range& e, const std::size_t& key, const std::vector<std::any>& data
);
 
 
class NEON_TYPE_VISIBLE TokenList
{
public:
 
    TokenList();
 
    TokenList(const TokenList&);
 
    TokenList(const std::vector<std::any>& data, size_t nextIndex = 0);
 
    TokenList(const std::initializer_list<std::any>& initList);
 
    void insert(const std::any& value);
 
    void remove(size_t index);
 
    [[nodiscard]] bool empty() const;
 
    template<typename ReturnType>
    ReturnType popFront()
    {
        ReturnType ret {get<ReturnType>(0)};
        data_.erase(data_.begin());
        return ret;
    }
 
    [[nodiscard]] size_t size() const;
 
    void reset() const { nextIndex_ = 0; }
 
    template<typename ReturnType>
    [[nodiscard]] ReturnType& get(const size_t& idx)
    {
        try
        {
            return std::any_cast<ReturnType&>(data_.at(idx));
        }
        catch (const std::bad_any_cast& e)
        {
            logBadAnyCast<ReturnType>(e, idx, data_);
            throw e;
        }
        catch (const std::out_of_range& e)
        {
            logOutRange(e, idx, data_);
            throw e;
        }
    }
 
    template<typename ReturnType>
    ReturnType& next()
    {
        ReturnType& retValue = get<ReturnType&>(nextIndex_);
        nextIndex_++;
        return retValue;
    }
 
    template<typename ReturnType>
    [[nodiscard]] const ReturnType& get(const size_t& idx) const
    {
        try
        {
            return std::any_cast<const ReturnType&>(data_.at(idx));
        }
        catch (const std::bad_any_cast& e)
        {
            logBadAnyCast<ReturnType>(e, idx, data_);
            throw e;
        }
        catch (const std::out_of_range& e)
        {
            logOutRange(e, idx, data_);
            throw e;
        }
    }
 
    template<typename ReturnType>
    const ReturnType& next() const
    {
        const ReturnType& retValue = get<ReturnType>(nextIndex_);
        nextIndex_++;
        return retValue;
    }
 
    template<typename ReturnType>
    [[nodiscard]] bool peekIs() const
    {
        return nextIndex_ < data_.size() && data_[nextIndex_].type() == typeid(ReturnType);
    }
 
    [[nodiscard]] std::any& operator[](const size_t& idx);
 
    [[nodiscard]] std::vector<std::any>& tokens();
 
 
private:
 
    std::vector<std::any> data_;
    mutable size_t nextIndex_;
};
 
} // namespace NeoN