dynamic_string_view.hpp

// Copyright (C) 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/basic_types.hpp"
 
#include <string_view>
 
namespace arg_router::utility
{
// NOLINTNEXTLINE(hicpp-special-member-functions)
class dynamic_string_view
{
public:
    using value_type = string::value_type;                    
    using allocator_type = string::allocator_type;            
    using size_type = string::size_type;                      
    using difference_type = string::difference_type;          
    using const_reference = string::const_reference;          
    using const_pointer = string::const_pointer;              
    using const_iterator = std::string_view::const_iterator;  
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    dynamic_string_view(std::string_view sv = {}) noexcept : view_{sv} {}
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    dynamic_string_view(const char* str) noexcept : view_{str} {}
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    dynamic_string_view(string&& str) noexcept : str_{std::move(str)} { update_view(); }
 
    dynamic_string_view(const dynamic_string_view& other) : view_{other.view_}, str_{other.str_}
    {
        if (!str_.empty()) {
            update_view();
        }
    }
 
    dynamic_string_view(dynamic_string_view&& other) noexcept : dynamic_string_view{}
    {
        swap(*this, other);
    }
 
    dynamic_string_view& operator=(dynamic_string_view other)
    {
        swap(*this, other);
        return *this;
    }
 
    void convert_to_internal_storage()
    {
        if (str_.empty()) {
            str_ = view_;
            update_view();
        }
    }
 
    // NOLINTNEXTLINE(google-explicit-constructor,hicpp-explicit-conversions)
    [[nodiscard]] operator std::string_view() const noexcept { return view_; }
 
    [[nodiscard]] bool operator==(const dynamic_string_view& other) const noexcept
    {
        return view_ == other.view_;
    }
 
    [[nodiscard]] bool operator!=(const dynamic_string_view& other) const noexcept
    {
        return !(*this == other);
    }
 
    template <typename T,
              typename = std::enable_if_t<!std::is_same_v<std::decay_t<T>, dynamic_string_view>>>
    dynamic_string_view& operator+=(T&& other)
    {
        convert_to_internal_storage();
        str_ += std::forward<T>(other);
        update_view();
 
        return *this;
    }
 
    dynamic_string_view& operator+=(const dynamic_string_view& other)
    {
        convert_to_internal_storage();
        str_ += other.view_;
        update_view();
 
        return *this;
    }
 
    [[nodiscard]] size_type size() const noexcept { return view_.size(); }
    [[nodiscard]] size_type internal_storage_size() const noexcept { return str_.size(); }
    [[nodiscard]] bool empty() const noexcept { return view_.empty(); }
 
    [[nodiscard]] const_iterator begin() const noexcept { return view_.begin(); }
    [[nodiscard]] const_iterator end() const noexcept { return view_.end(); }
 
    friend void swap(dynamic_string_view& a, dynamic_string_view& b)
    {
        using std::swap;
 
        swap(a.view_, b.view_);
        swap(a.str_, b.str_);
 
        if (!a.str_.empty()) {
            a.update_view();
        }
        if (!b.str_.empty()) {
            b.update_view();
        }
    }
 
private:
    void update_view() { view_ = str_; }
 
    std::string_view view_;
    string str_;
};
 
inline std::ostream& operator<<(std::ostream& stream, const dynamic_string_view& dsv)
{
    return stream << static_cast<std::string_view>(dsv);
}
 
template <typename T>
[[nodiscard]] inline dynamic_string_view operator+(dynamic_string_view a, T&& b)
{
    a += std::forward<T>(b);
    return a;
}
}  // namespace arg_router::utility