string_buffer.h

Go to the documentation of this file.

#pragma once
 
#include <algorithm>
#include <array>
#include <cstring>
#include <string_view>
 
#ifdef EMLABCPP_USE_NLOHMANN_JSON
#include <nlohmann/json.hpp>
#endif
 
namespace emlabcpp
{
 
template < std::size_t N >
struct string_buffer
{
        static constexpr std::size_t capacity = N;
        using base_type                       = std::array< char, N >;
 
        constexpr string_buffer()
        {
                std::fill_n( this->data(), N, '\0' );
        }
 
        constexpr string_buffer( std::string_view sv )
          : string_buffer()
        {
                std::copy_n( sv.begin(), std::min( sv.size(), N - 1 ), this->begin() );
        }
 
        template < std::size_t M >
        constexpr string_buffer( char const ( &msg )[M] )
          : string_buffer()
        {
                static_assert( M < N );
                std::copy_n( msg, M, this->begin() );
        }
 
        template < std::size_t M >
        constexpr string_buffer( string_buffer< M > const& msg )
          : string_buffer()
        {
                static_assert( M < N );
                std::copy_n( msg.data(), M, this->begin() );
        }
 
        operator std::string_view() const
        {
                return this->sv();
        }
 
        std::string_view sv() const
        {
                return std::string_view( this->data(), size() );
        }
 
        constexpr auto begin()
        {
                return data_.begin();
        }
 
        constexpr auto begin() const
        {
                return data_.begin();
        }
 
        constexpr auto end()
        {
                return data_.end();
        }
 
        constexpr auto end() const
        {
                return data_.end();
        }
 
        constexpr char* data()
        {
                return data_.data();
        }
 
        constexpr char const* data() const
        {
                return data_.data();
        }
 
        [[nodiscard]] constexpr std::size_t size() const
        {
                for ( std::size_t i = 0; i < N; i++ )
                        if ( data_[i] == '\0' )
                                return i;
                return N;
        }
 
        template < std::size_t M >
        constexpr auto operator<=>( string_buffer< M > const& other ) const noexcept
        {
                return std::string_view{ *this } <=> std::string_view{ other };
        }
 
        template < std::size_t M >
        constexpr bool operator==( string_buffer< M > const& other ) const noexcept
        {
                return std::string_view{ *this } == std::string_view{ other };
        }
 
        constexpr bool operator==( std::string_view other ) const noexcept
        {
                return std::string_view{ *this } == other;
        }
 
        string_buffer& extend( std::string_view sv )
        {
                std::size_t curr_size = size();
                std::copy_n(
                    sv.begin(),
                    std::min( sv.size(), N - 1 - curr_size ),
                    this->begin() + curr_size );
                return *this;
        }
 
private:
        std::array< char, N > data_;
};
 
namespace bits
{
        template < typename T >
        struct is_string_buffer
        {
                static constexpr bool value = false;
        };
 
        template < std::size_t N >
        struct is_string_buffer< string_buffer< N > >
        {
                static constexpr bool value = true;
        };
 
}  // namespace bits
 
template < typename T >
concept is_string_buffer_v = bits::is_string_buffer< T >::value;
 
template < std::size_t N >
std::ostream& operator<<( std::ostream& os, string_buffer< N > const& sb )
{
        return os << std::string_view( sb );
}
 
#ifdef EMLABCPP_USE_NLOHMANN_JSON
 
template < std::size_t N >
void to_json( nlohmann::json& j, string_buffer< N > const& buffer )
{
        j = std::string_view{ buffer };
}
 
template < std::size_t N >
void from_json( nlohmann::json const& j, string_buffer< N >& buffer )
{
        std::string const s = j;
        buffer              = string_buffer< N >( std::string_view{ s } );
}
 
#endif
 
}  // namespace emlabcpp