Basic Shared String implementation, using a shared_ptr

#include <memory>
#include <string>
#include <utility>
#include <string_view>
#include <type_traits>

#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>

template<class STRING_T>
constexpr decltype(auto) string_data(const STRING_T& str)
{
    if constexpr(   std::is_array_v<STRING_T>
                 || std::is_pointer_v<STRING_T>)
    {
        return str;
    }
    else
    {
        return str.data();
    }
} // string_data()


//-----------------------------------------------------------------------------

template<class STRING_T>
constexpr size_t string_size(const STRING_T & str)
{
    if constexpr(std::is_pointer_v<STRING_T>)
    {
        return std::char_traits<std::remove_pointer_t<STRING_T>>::length(str);
    }
    else if constexpr(std::is_array_v<STRING_T>)
    {
        // TODO: Throw if the array contains an embedded nul character.
        // TODO: Return the static size based on template deduction.
        return std::char_traits<std::remove_pointer_t<std::decay_t<STRING_T>>>::length(str);
    }
    else
    {
        return str.size();
    }
} // string_size()


//-----------------------------------------------------------------------------
// Declaration of BasicSharedString
//-----------------------------------------------------------------------------
template<typename CHAR_T>
class BasicSharedString : private boost::shared_ptr<const CHAR_T[]>
                        , public std::basic_string_view<CHAR_T>
{
    using SPBase_t = boost::shared_ptr<const CHAR_T[]>;
    using SVBase_t = std::basic_string_view<CHAR_T>;

public:
    using traits_type            = typename SVBase_t::traits_type;
    using value_type             = typename SVBase_t::value_type;
    using size_type              = typename SVBase_t::size_type;
    using difference_type        = typename SVBase_t::difference_type;
    using reference              = typename SVBase_t::reference;
    using const_reference        = typename SVBase_t::const_reference;
    using pointer                = typename SVBase_t::pointer;
    using const_pointer          = typename SVBase_t::const_pointer;
    using iterator               = typename SVBase_t::iterator;
    using const_iterator         = typename SVBase_t::const_iterator;
    using reverse_iterator       = typename SVBase_t::reverse_iterator;
    using const_reverse_iterator = typename SVBase_t::const_reverse_iterator;

    static constexpr size_type npos = SVBase_t::npos;

    BasicSharedString(void);
    BasicSharedString(BasicSharedString &&);
    BasicSharedString(BasicSharedString const&);
    BasicSharedString& operator=(BasicSharedString &&);
    BasicSharedString& operator=(BasicSharedString const&);

    BasicSharedString(const CHAR_T* s, size_type count);
    template<typename STR_T>
    BasicSharedString(STR_T const& str);

    BasicSharedString substr(size_type offset, size_type length) const;

    void swap(BasicSharedString& other);

    template<typename C_T>
    friend void swap(BasicSharedString<C_T>& rhs, BasicSharedString<C_T>& lhs);

private:
    BasicSharedString(SPBase_t lifetime, SVBase_t view);
    BasicSharedString(SPBase_t lifetime, size_type count);
}; // class BasicSharedString

/**
 * By default, don't instantiate this template.
 * We'll do this in shared_string.cpp
 */
extern template class BasicSharedString<char>;

/**
 * The default implementation of a BasicSharedString.
 */
using SharedString  = BasicSharedString<char>;

//-----------------------------------------------------------------------------
/**
 * Comparison operators.
 */
template<typename CHAR_T>
bool operator==(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs);
template<typename CHAR_T>
bool operator!=(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs);
template<typename CHAR_T>
bool operator<(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs);
template<typename CHAR_T>
bool operator<=(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs);
template<typename CHAR_T>
bool operator>(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs);
template<typename CHAR_T>
bool operator>=(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs);

template<typename CHAR_T, typename OTHER_T>
bool operator==(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs);
template<typename CHAR_T, typename OTHER_T>
bool operator!=(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs);
template<typename CHAR_T, typename OTHER_T>
bool operator<(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs);
template<typename CHAR_T, typename OTHER_T>
bool operator<=(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs);
template<typename CHAR_T, typename OTHER_T>
bool operator>(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs);
template<typename CHAR_T, typename OTHER_T>
bool operator>=(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs);

template<typename OTHER_T, typename CHAR_T>
bool operator==(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs);
template<typename OTHER_T, typename CHAR_T>
bool operator!=(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs);
template<typename OTHER_T, typename CHAR_T>
bool operator<(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs);
template<typename OTHER_T, typename CHAR_T>
bool operator<=(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs);
template<typename OTHER_T, typename CHAR_T>
bool operator>(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs);
template<typename OTHER_T, typename CHAR_T>
bool operator>=(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs);

template<typename OTHER_T, typename CHAR_T>
OTHER_T & operator<<(OTHER_T & other, BasicSharedString<CHAR_T> const& rhs);

//-----------------------------------------------------------------------------
// Implementation of BasicSharedString
//-----------------------------------------------------------------------------

template<typename CHAR_T>
inline BasicSharedString<CHAR_T>::BasicSharedString(void) = default;

template<typename CHAR_T>
inline BasicSharedString<CHAR_T>::BasicSharedString(BasicSharedString &&) = default;

template<typename CHAR_T>
inline BasicSharedString<CHAR_T>::BasicSharedString(BasicSharedString const&) = default;

template<typename CHAR_T>
inline auto BasicSharedString<CHAR_T>::operator=(BasicSharedString &&) -> BasicSharedString& = default;

template<typename CHAR_T>
inline auto BasicSharedString<CHAR_T>::operator=(BasicSharedString const&) -> BasicSharedString& = default;

template<typename CHAR_T>
inline BasicSharedString<CHAR_T>::BasicSharedString(SPBase_t ptr, SVBase_t const view)
 : SPBase_t(std::move(ptr))
 , SVBase_t(view)
{ }

template<typename CHAR_T>
inline BasicSharedString<CHAR_T>::BasicSharedString(SPBase_t ptr, size_type const count)
 : SPBase_t(std::move(ptr))
 , SVBase_t(SPBase_t::get(), count)
{ }

template<typename CHAR_T>
inline BasicSharedString<CHAR_T>::BasicSharedString(const CHAR_T* const s, size_type const count)
 : BasicSharedString([](const CHAR_T* const s, size_type const count)
                     {
                         auto ptr = boost::make_shared<CHAR_T[]>(count);
                         std::copy(s, s+count, ptr.get());
                         return std::move(ptr);
                     }(s, count),
                     count)
{ }

template<typename CHAR_T>
  template<typename STR_T>
inline BasicSharedString<CHAR_T>::BasicSharedString(STR_T const& str)
 : BasicSharedString(meshpp::core::string_data(str), meshpp::core::string_size(str))
{ }

template<typename CHAR_T>
inline auto BasicSharedString<CHAR_T>::substr(size_type const offset, size_type const length) const -> BasicSharedString
{
    // *this will convert to the base class, SPBase_t, so this isn't a call to the copy constructor.
    return BasicSharedString(*this, SVBase_t::substr(offset, length));
}

template<typename CHAR_T>
inline void BasicSharedString<CHAR_T>::swap(BasicSharedString & other)
{
    using std::swap; // Allow Argument Dependent Lookup
    swap(static_cast<SPBase_t&>(*this), static_cast<SPBase_t&>(other));
    swap(static_cast<SVBase_t&>(*this), static_cast<SVBase_t&>(other));
}

template<typename CHAR_T>
inline void swap(BasicSharedString<CHAR_T>& rhs, BasicSharedString<CHAR_T>& lhs)
{
    rhs.swap(lhs);
}

//-----------------------------------------------------------------------------

template<typename CHAR_T>
bool operator==(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 == lhs.compare(rhs);
}

template<typename CHAR_T>
bool operator!=(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 != lhs.compare(rhs);
}

template<typename CHAR_T>
bool operator<(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 < lhs.compare(rhs);
}

template<typename CHAR_T>
bool operator<=(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 <= lhs.compare(rhs);
}

template<typename CHAR_T>
bool operator>(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 > lhs.compare(rhs);
}

template<typename CHAR_T>
bool operator>=(BasicSharedString<CHAR_T> const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 >= lhs.compare(rhs);
}

template<typename CHAR_T, typename OTHER_T>
bool operator==(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs)
{
    return 0 == lhs.compare(rhs);
}

template<typename CHAR_T, typename OTHER_T>
bool operator!=(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs)
{
    return 0 != lhs.compare(rhs);
}

template<typename CHAR_T, typename OTHER_T>
bool operator<(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs)
{
    return 0 < lhs.compare(rhs);
}

template<typename CHAR_T, typename OTHER_T>
bool operator<=(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs)
{
    return 0 <= lhs.compare(rhs);
}

template<typename CHAR_T, typename OTHER_T>
bool operator>(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs)
{
    return 0 > lhs.compare(rhs);
}

template<typename CHAR_T, typename OTHER_T>
bool operator>=(BasicSharedString<CHAR_T> const& lhs, OTHER_T const& rhs)
{
    return 0 >= lhs.compare(rhs);
}

template<typename OTHER_T, typename CHAR_T>
bool operator==(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 == lhs.compare(rhs);
}

template<typename OTHER_T, typename CHAR_T>
bool operator!=(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 != lhs.compare(rhs);
}

template<typename OTHER_T, typename CHAR_T>
bool operator<(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 > lhs.compare(rhs);
}

template<typename OTHER_T, typename CHAR_T>
bool operator<=(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 >= lhs.compare(rhs);
}

template<typename OTHER_T, typename CHAR_T>
bool operator>(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 < lhs.compare(rhs);
}

template<typename OTHER_T, typename CHAR_T>
bool operator>=(OTHER_T const& lhs, BasicSharedString<CHAR_T> const& rhs)
{
    return 0 <= lhs.compare(rhs);
}

template<typename OTHER_T, typename CHAR_T>
OTHER_T & operator<<(OTHER_T & other, BasicSharedString<CHAR_T> const& rhs)
{
    other << static_cast<std::basic_string_view<CHAR_T> const&>(rhs);
    return other;
}