dynamic_token_adapter.hpp

// Copyright (C) 2022-2023 by Camden Mannett.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE or copy at https://www.boost.org/LICENSE_1_0.txt)
 
#pragma once
 
#include "arg_router/parsing/token_type.hpp"
 
namespace arg_router::parsing
{
class dynamic_token_adapter
{
public:
    using value_type = token_type;
    using size_type = std::size_t;
 
    class iterator
    {
    public:
        using difference_type = std::ptrdiff_t;
        using value_type = dynamic_token_adapter::value_type;
        using pointer = const value_type*;
        using reference = const value_type&;
        using iterator_category = std::forward_iterator_tag;
 
        iterator& operator+=(difference_type offset) noexcept
        {
            i_ += offset;
            return *this;
        }
 
        iterator& operator-=(difference_type offset) noexcept { return (*this += -offset); }
 
        [[nodiscard]] friend iterator operator+(iterator it, difference_type offset) noexcept
        {
            return it += offset;
        }
 
        [[nodiscard]] friend iterator operator-(iterator it, difference_type offset) noexcept
        {
            return it -= offset;
        }
 
        [[nodiscard]] friend iterator operator+(difference_type offset, iterator it) noexcept
        {
            return it += offset;
        }
 
        [[nodiscard]] friend iterator operator-(difference_type offset, iterator it) noexcept
        {
            return it -= offset;
        }
 
        [[nodiscard]] friend iterator operator-(iterator lhs, iterator rhs) noexcept
        {
            return {lhs.owner_, lhs.i_ - rhs.i_};
        }
 
        [[nodiscard]] friend bool operator<(iterator lhs, iterator rhs) noexcept
        {
            return lhs.i_ < rhs.i_;
        }
 
        [[nodiscard]] friend bool operator>(iterator lhs, iterator rhs) noexcept
        {
            return rhs < lhs;
        }
 
        [[nodiscard]] friend bool operator<=(iterator lhs, iterator rhs) noexcept
        {
            return !(lhs > rhs);
        }
 
        [[nodiscard]] friend bool operator>=(iterator lhs, iterator rhs) noexcept
        {
            return !(lhs < rhs);
        }
 
        iterator& operator++() noexcept { return (*this += 1); }
 
        iterator operator++(int) noexcept
        {
            auto tmp = *this;
            *this += 1;
            return tmp;
        }
 
        iterator& operator--() noexcept { return (*this -= 1); }
 
        iterator operator--(int) noexcept
        {
            auto tmp = *this;
            *this -= 1;
            return tmp;
        }
 
        [[nodiscard]] reference operator*() const noexcept
        {
            if (i_ >= static_cast<difference_type>(processed().size())) {
                const auto i = i_ - processed().size();
                return unprocessed()[i];
            }
 
            return processed()[i_];
        }
 
        [[nodiscard]] pointer operator->() const noexcept { return &(*(*this)); }
 
        [[nodiscard]] reference operator[](difference_type offset) const noexcept
        {
            return *(*this + offset);
        }
 
        [[nodiscard]] bool operator==(iterator other) const noexcept
        {
            const auto is_this_end = is_end();
            const auto is_other_end = other.is_end();
 
            // Both end() iterators
            if (is_this_end && is_other_end) {
                return true;
            }
            if (is_this_end || is_other_end) {
                return false;
            }
 
            return (owner_ == other.owner_) && (i_ == other.i_);
        }
 
        [[nodiscard]] bool operator!=(iterator other) const noexcept { return !(*this == other); }
 
        void set(value_type value)
        {
            owner_->transfer(*this);
            processed()[i_] = value;
        }
 
    private:
        friend class dynamic_token_adapter;
 
        iterator() : owner_{nullptr}, i_{0} {}
 
        iterator(dynamic_token_adapter* owner, difference_type i) : owner_{owner}, i_{i} {}
 
        [[nodiscard]] bool is_end() const noexcept
        {
            return !owner_ || (i_ >= static_cast<difference_type>(owner_->size()));
        }
 
        [[nodiscard]] vector<token_type>& processed() const { return *(owner_->processed_); }
 
        [[nodiscard]] vector<token_type>& unprocessed() const { return *(owner_->unprocessed_); }
 
        dynamic_token_adapter* owner_;
        difference_type i_;
    };
 
    dynamic_token_adapter(vector<token_type>& processed, vector<token_type>& unprocessed) :
        processed_{&processed}, unprocessed_{&unprocessed}
    {
        // Perform a reserve for all the tokens.  There is a resonable chance that more processed
        // than unprocessed tokens will be needed (due to short-form expansion, value separation,
        // etc.), but this should still dramatically reduce the number of allocations needed
        unprocessed_->reserve(size());
    }
 
    [[nodiscard]] bool operator==(dynamic_token_adapter other) const
    {
        return (processed_ == other.processed_) && (unprocessed_ == other.unprocessed_);
    }
 
    [[nodiscard]] bool operator!=(dynamic_token_adapter other) const { return !(*this == other); }
 
    [[nodiscard]] iterator begin() { return {this, 0}; }
 
    // NOLINTNEXTLINE(readability-convert-member-functions-to-static)
    [[nodiscard]] iterator end() { return {}; }
 
    [[nodiscard]] size_type size() const { return processed_->size() + unprocessed_->size(); }
 
    [[nodiscard]] bool empty() const { return processed_->empty() && unprocessed_->empty(); }
 
    [[nodiscard]] vector<value_type>& processed() { return *processed_; }
 
    [[nodiscard]] vector<value_type>& unprocessed() { return *unprocessed_; }
 
    iterator insert(iterator it, value_type value)
    {
        // Only transfer up to the element before the target position, otherwise we transfer that
        // and then insert the new value, which isn't expected
        transfer(it - 1);
        auto processed_it = it.is_end() ? processed_->end() :  //
                                          processed_->begin() + it.i_;
 
        processed_->insert(processed_it, value);
        return {this, it.i_};
    }
 
    template <typename Iter>
    iterator insert(iterator it, Iter first, Iter last)
    {
        // Only transfer up to the element before the target position, otherwise we transfer that
        // and then insert the new value, which isn't expected
        transfer(it - 1);
        auto processed_it = it.is_end() ? processed_->end() :  //
                                          processed_->begin() + it.i_;
 
        processed_->insert(processed_it, first, last);
        return {this, it.i_};
    }
 
    iterator erase(iterator it)
    {
        // If the iterator is an end(), it's a no-op
        if (it.is_end()) {
            return it;
        }
 
        const auto processed_size = static_cast<iterator::difference_type>(processed_->size());
        if (it.i_ < processed_size) {
            processed_->erase(processed_->begin() + it.i_);
        } else {
            const auto offset = it.i_ - processed_size;
            unprocessed_->erase(unprocessed_->begin() + offset);
        }
 
        return it;
    }
 
    void transfer(iterator it)
    {
        // If the iterator is an end(), then consume all the unprocessed tokens
        if (it.is_end()) {
            it.i_ = size() - 1;
        }
 
        if ((it.i_ < 0) || (it.i_ < static_cast<iterator::difference_type>(processed_->size()))) {
            return;
        }
 
        const auto count = (it.i_ + 1) - processed_->size();
        processed_->insert(processed_->end(), unprocessed_->begin(), unprocessed_->begin() + count);
        unprocessed_->erase(unprocessed_->begin(), unprocessed_->begin() + count);
    }
 
private:
    vector<token_type>* processed_;
    vector<token_type>* unprocessed_;
};
}  // namespace arg_router::parsing