processed_text.h

Go to the documentation of this file.

#ifndef PROCESSED_TEXT_H
#define PROCESSED_TEXT_H
 
#include <array>
#include <type_traits>
#include <variant>
 
namespace mazes
{
    class processed_text final
    {
        using artifacts = std::variant<std::monostate, std::string, std::string_view, char*>;
 
        static constexpr auto DIRTY_INDEX = 0, PROCESSED_INDEX = 1, BUFFER_SIZE = 2;
 
    public:
        [[nodiscard]] artifacts get_dirty() const noexcept { return doubled_buffer.at(DIRTY_INDEX); }
 
        [[nodiscard]] artifacts get_processed() const noexcept { return doubled_buffer.at(PROCESSED_INDEX); }
 
        void set_dirty(artifacts anything) noexcept { doubled_buffer.at(DIRTY_INDEX) = std::move(anything); }
 
        void set_processed(artifacts anything) noexcept { doubled_buffer.at(PROCESSED_INDEX) = std::move(anything); }
 
        bool set(const std::string_view sv) noexcept
        {
            set_dirty(std::string{sv});
            return true;
        }
 
        [[nodiscard]] bool is_clean() const noexcept
        {
            return std::visit([]<typename T0>(const T0& value) -> bool
            {
                using T = std::decay_t<T0>;
                if constexpr (std::is_same_v<T, std::monostate>)
                {
                    return true; // Consider monostate as clean
                }
                else if constexpr (std::is_same_v<T, std::string> || std::is_same_v<T, std::string_view>)
                {
                    return value.empty();
                }
                else if constexpr (std::is_same_v<T, char*>)
                {
                    return value == nullptr || *value == '\0';
                }
                else
                {
                    return false;
                }
            }, get_dirty());
        }
 
    private:
        std::array<artifacts, BUFFER_SIZE> doubled_buffer;
    };
}
 
#endif // PROCESSED_TEXT_H