string_builder.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_STRING_STRING_BUILDER_HPP__
#define NEFORCE_CORE_STRING_STRING_BUILDER_HPP__

 
#include "NeForce/core/interface/istringify.hpp"
NEFORCE_BEGIN_NAMESPACE__


class string_builder {
public:
    string_builder() = default;

    void reserve_pieces(const size_t n) { pieces_.reserve(n); }

    void reserve(const size_t n) { reserved_size_ = n; }

    string_builder& append(const string_view sv) {
        pieces_.push_back(sv);
        total_size_ += sv.size();
        return *this;
    }

    string_builder& append(const string& str) { return append(str.view()); }

    string_builder& append(const char* str) { return append(string_view(str)); }

    string_builder& append(const char c) {
        owned_pieces_.emplace_back(1, c);
        pieces_.push_back(owned_pieces_.back().view());
        total_size_ += 1;
        return *this;
    }

    template <typename T, typename P = package_t<T>,
              enable_if_t<is_packaged_v<T> && is_base_of_v<istringify<P>, P>, int> = 0>
    string_builder& append(const T& value) {
        owned_pieces_.push_back(P(value).to_string());
        pieces_.push_back(owned_pieces_.back().view());
        total_size_ += owned_pieces_.back().size();
        return *this;
    }

    template <typename T, enable_if_t<is_base_of_v<istringify<T>, T>, int> = 0>
    string_builder& append(const T& value) {
        owned_pieces_.push_back(value.to_string());
        pieces_.push_back(owned_pieces_.back().view());
        total_size_ += owned_pieces_.back().size();
        return *this;
    }

    NEFORCE_NODISCARD string build() const {
        string result;
        const size_t alloc_size = max(reserved_size_, total_size_);
        result.reserve(alloc_size);
        for (const auto& piece: pieces_) {
            result.append(piece.data(), piece.size());
        }
        return result;
    }

    NEFORCE_NODISCARD operator string() const { return build(); }

    NEFORCE_NODISCARD size_t size() const noexcept { return total_size_; }

    NEFORCE_NODISCARD bool empty() const noexcept { return total_size_ == 0; }

    void clear() noexcept {
        pieces_.clear();
        owned_pieces_.clear();
        total_size_ = 0;
        reserved_size_ = 0;
    }
 
private:
    vector<string_view> pieces_;  
    vector<string> owned_pieces_; 
    size_t total_size_ = 0;       
    size_t reserved_size_ = 0;    
};

NEFORCE_BEGIN_INNER__
 
#ifdef NEFORCE_STANDARD_17
template <typename... Args>
void __concat_append(string_builder& sb, Args&&... args) {
    (sb.append(_NEFORCE forward<Args>(args)), ...);
}
#else
template <typename First, typename... Rest>
void __concat_append(string_builder& sb, First&& first, Rest&&... rest) {
    sb.append(_NEFORCE forward<First>(first));
    __concat_append(sb, _NEFORCE forward<Rest>(rest)...);
}
template <typename Last>
void __concat_append(string_builder& sb, Last&& last) {
    sb.append(_NEFORCE forward<Last>(last));
}
#endif
 
NEFORCE_END_INNER__

template <typename... Args, enable_if_t<(sizeof...(Args) > 0), int> = 0>
NEFORCE_NODISCARD string concatenate(Args&&... args) {
    string_builder sb;
    inner::__concat_append(sb, _NEFORCE forward<Args>(args)...);
    return sb.build();
}
 // String
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_STRING_STRING_BUILDER_HPP__