managed_string.hpp

 
//
// Autores 2024 Realm Inc.
//
// Licenciado sob a Licença Apache, Versão 2.0 (a "Licença");
// você não pode usar este arquivo, exceto em conformidade com a Licença.
// Você pode obter uma cópia da Licença em
//
// http://www.apache.org/license/LICENSE-2.0
//
// A menos que exigido pela lei aplicável ou acordado por escrito, o software
// distribuído sob a Licença é distribuído "Como está",
// sem garantias ou condições de qualquer tipo, Express ou implícitas.
// Consulte a Licença para obter as permissões específicas de domínio do idioma e
// limitações da Licença.
//
 
#ifndef CPPREALM_MANAGED_STRING_HPP
#define CPPREALM_MANAGED_STRING_HPP
 
#include <cprealm/macros.hpp>
 
namespace Realm {
    classe rbool;
}
 
namespace Realm {
    //Marca: - referência de caractere
    estrutura, estrutura chart_reference {
        chart_reference& operator =(caracteres c);
    privado:
        chart_reference(managed<std::string>* principal, size_t idx);
        template <typename, typename> help struct realm::managed;
        amigo estrutura, estrutura chart_pointer;
        managed<std::string>* m_parent;
        size_t m_idx;
 };
    //Marca: - referência de caractere const
    estrutura, estrutura const_char_reference {
        operador chart() const; //NOLINT(google-explicit-constructor)
    privado:
        const_char_reference(const managed<std::string>* pai, size_t idx);
        template <typename, typename> help struct realm::managed;
        amigo estrutura, estrutura const_char_pointer;
        const managed<std::string>* m_parent;
        size_t m_idx;
 };
    //Marca: - ponteiro de caracteres
    estrutura, estrutura chart_pointer {
        operador chart_reference [](tamanho_t idx);
    privado:
        explícito chart_pointer(managed<std::string>* pai);
        template <typename, typename> help struct realm::managed;
        managed<std::string>* m_parent;
 };
    //Marca: - ponteiro de caracteres const
    estrutura, estrutura const_char_pointer {
        operador const_char_reference [](tamanho_t idx) const;
    privado:
        explícito const_char_pointer(const managed<std::string>* principal);
        template <typename, typename> help struct realm::managed;
        const managed<std::string>* m_parent;
 };
 
    //Marca: - string gerenciada
    template <> struct managed<std::string> : managed_base {
        usando value_type = std::string;
        Usando gerenciado<std::string>::managed_base::managed_base;
        Usando gerenciado<std::string>::managed_base::operator=;
 
 [[nodiscard]] std::string detach() const;
 
        Usando reference = char_reference;
        Usando const_reference = const_char_reference;
 
        operador & gerenciado=(std::string&& v) { set(std::move(v)); retornar *isso; }
        managed& operator =(const std::string& v) { set(v); retornar *isso; }
        operador & gerenciado=(const chart* v) { set(v); retornar *isso; }
 
        //Marca: - acesso ao elemento
        referência at(size_t idx);
        operador de referência [](size_t idx);
 
 [[nodiscard]] const_reference front() const;
        frente de referência ();
 [[nodiscard]] const_reference back() const;
        referência de volta();
        chart_pointer data();
 [[nodiscard]] const_char_pointer data() const;
 
 [[nodiscard]] const_char_pointer c_str() const;
 
        operador std::string_view() const = excluir;
        operador std::string() const;
 
 
 [[nodiscard]] size_t size() const noexceto;
        //Marca: - operações
        vazio clear() noexceto;
        push_back nulo (caracteres c);
        managed& append(const std::string&);
        managed& operator+=(const std::string&);
        vazio pop_back();
 
        //Marca: - operadores de comparação
        rbool operator==(const std::string& rhs) const noexceto;
        rbool operator==(const chart * rhs) const noexceto ;
        operador de rbool !=(const std::string& rhs) const noexceto;
        operador de rbool !=(const chart * rhs) const noexceto ;
        rbool contains(const std::string &s, bool case_sensitive = true) const noexceto;
        rbool empty() const noexceto;
 privado:
 estrutura de amigo Chart_reference;
 estrutura de amigo const_char_reference;
        vazio inline set(const std::string& v) { m_obj->template set<std::string>(m_key, v); }
 [[nodiscard]] inline std::string get() const { return m_obj->get<std::string>(m_key); }
 managed() = padrão;
 managed(const managed&) = delete;
 managed(managed &&) = excluir;
 managed& operator=(const managed&) = excluir;
 managed& operator=(managed&&) = excluir;
        modelo<typename, typename>
        amigo estrutura managed;
 };
 
    template <> struct managed<std::optional<std::string>> final : public managed<std::string> {
        usando value_type = std::opcional<std::string>;
        Usando gerenciado<std::string>::operator=;
        managed& operator =(std::optional<std::string>&& v) { set(std::move(v)); retornar *isso; }
        managed& operator =(const std::optional<std::string>& v) { set(v); retornar *isso; }
        operador & gerenciado=(const chart* v) { set(v); retornar *isso; }
 
 [[nodiscard]] std::opcional<std::string> detach() const {
            return m_obj->template get_optional<std::string>(m_key);
 }
 
 [[nodiscard]] std::opcional<std::string> operador *() const {
            return desvincular();
 }
 
 [[nodiscard]] operador std::opcional<std::string>() const {
            return desvincular();
 }
 
        rbool operator==(const std::opcional<std::string>& rhs) const noexceto;
        operador rbool !=(const std::optional<std::string>& rhs) const noexceto;
    privado:
        vazio inline set(const std::optional<std::string>& v) { m_obj->template set<std::optional<std::string>>(m_key, v); }
        managed() = default;
        managed(const managed&) = delete;
        managed(managed &&) = delete;
        managed& operator=(const managed&) = delete;
        managed& operator=(managed&&) = delete;
        modelo<typename, typename>
        amigo estrutura, estrutura managed;
 };
}
 
#endif //CPPrealm_MANAGED_STRING_HPP