C_string_value

#pragma once
#include <cppm/text/C_string_view.hpp>
#include <cppm/text/Lightweight_pascal_string.hpp>
#include <cppm/syntactic_sugar/$unreachable.hpp>
#include <cppm/syntactic_sugar/const_.hpp>

#include <memory>
#include <utility>
#include <variant>

#include <cstring>

namespace cppm {
    using   std::shared_ptr, std::make_shared,  // <memory>
            std::move,                          // <utility>
            std::get, std::variant;             // <variant>

    using   std::strcpy;                        // <cstring>

    class C_string_value
    {
        using Shared_static     = C_string_view;
        using Shared_dynamic    = shared_ptr<char[]>;       // Data, first bytes represent size.

        using Ps = Lightweight_pascal_string;               // For `Shared_dynamic`.

        enum{ var_static, var_dynamic };
        using Variant = variant<Shared_static, Shared_dynamic>;

        Variant m_value;

        auto get_static() const -> const Shared_static& { return get<var_static>( m_value ); }

        auto get_dynamic() const -> const Shared_dynamic& { return get<var_dynamic>( m_value ); }
        auto get_dynamic_storage() const -> char* { return get_dynamic().get(); }
        auto get_dynamic_ps() const -> Ps { return Ps( get_dynamic_storage() ); }

    protected:
        auto kind() const -> int { return int( m_value.index() ); }         // For testing & debugging.

    public:
        template< Nat n_bytes >
        C_string_value( in_<const char[n_bytes]> s ):
            m_value( Shared_static( s ) )
        {
            assert( s[n_bytes - 1] == '\0' );
        }

        C_string_value( in_<C_string_view> s ):
            m_value( make_shared<char[]>( Ps::size_for( s ) ) )
        {
            const_<char*> p_storage = get_dynamic_storage();
            Ps::create_in( p_storage, s );
        }

        auto c_str() const
            -> C_str
        {
            switch( m_value.index() ) {
                case +var_static:       { return get_static().c_str(); }
                case +var_dynamic:      { return get_dynamic_ps().c_str(); }
            }
            $unreachable();
        }

        auto sv() const
            -> C_string_view
        {
            switch( m_value.index() ) {
                case +var_static:       { return get_static(); };
                case +var_dynamic:      { return get_dynamic_ps().sv(); }
            }
            $unreachable();
        }

        auto std_sv() const -> string_view { return sv(); }
    };
}  // cppm