managed_string.hpp

 
//
// 版权所有 2024 Realm Inc.
//
// 根据 Apache 许可证 2.0 版（“许可证”）获得许可；
// 除非符合合规，否则不得使用此文件。
// 您可以在以下网址获取许可证副本：
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 除非适用法律要求或书面同意，否则软件
// 根据许可证分发是按“原样”分发的，
// 不提供任何类型的Express或暗示的保证或条件。
// 请参阅管理权限的特定语言的许可证和
// 许可证下的限制。
//
 
#ifndef CPPREALM_MANAGED_STRING_HPP
#define CPPREALM_MANAGED_STRING_HPP
 
#include <cpprealm/macros.hpp>
 
命名空间域 {
    class rbool;
 }
 
命名空间域 {
    //MARK: - char 引用
    struct char_reference {
        char_reference & Operator =( char c);
    private :
        char_reference ( managed<std::string> *parent, size_t idx);
        template < typename , typename > Friend struct realm::managed ;
        朋友 struct char_pointer ；
        managed<std::string> * m_parent;
        size_t m_idx;
 }；
    //MARK: - const char 引用
    struct const_char_reference {
        操作符 char() const ; //NOLINT(google-explicit-constructor)
    private :
        const_char_reference ( constmanaged <std::string> *parent, size_t idx);
        template < typename , typename > Friend struct realm::managed ;
        朋友 struct const_char_pointer ；
        const managed<std::string> * m_parent;
        size_t m_idx;
 }；
    //MARK: - char 指针
    struct char_pointer {
        char_reference Operator []( size_t idx);
    private :
        显式 char_pointer ( managed<std::string> *parent);
        template < typename , typename > Friend struct realm::managed ;
        managed<std::string> * m_parent;
 };
    //MARK: - const char 指针
    struct const_char_pointer {
        const_char_reference Operator []( size_t idx) const ;
    private :
        显式 const_char_pointer ( constmanaged <std::string>*parent);
        template < typename , typename > Friend struct realm::managed ;
        const managed<std::string> * m_parent;
 }；
 
    //MARK:-托管string
    template <> structmanaged <std::string>: Managed_base { {
        using value_type = std::string;
        运用 managed <std::string>::managed_base::managed_base;
        运用 托管 <std::string>::managed_base:: 操作符=;
 
 [[nodiscard]] std::string 分离() const ;
 
        运用 reference = char_reference ；
        运用 const_reference = const_char_reference ;
 
        Managed & Operator =(std::string&& v) { set(std::move(v)); return * this ; }
        Managed & Operator =( const std::string& v) { set(v); return * this ; }
        Managed & Operator =( const char * v) { set(v); return * this ; }
 
        //MARK: - 元素访问权限
        引用at( size_t idx);
        引用操作符[]( size_t idx);
 
 [[nodiscard]] const_reference front() const ;
        引用front();
 [[nodiscard]] const_reference back() const ;
        引用back()；
        char_pointer data();
 [[nodiscard]] const_char_pointer data() const ;
 
 [[nodiscard]] const_char_pointer c_str() const ;
 
        Operator std::string_view() const = delete ;
        操作符 std::string() const ；
 
 
 [[nodiscard]] size_t size() const noException;
        //MARK:- 操作
        void clear() noException;
        void push_back( char c);
        managed & append(const std:: string &);
        Managed & Operator+=(const std:: string &);
        voidpop_back ();
 
        //MARK:-比较操作符
        rbool Operator==(const std:: string & rhs) const noException;
        rbool Operator==(const char * rhs) const noException;
        rbool操作符!=(const std:: string & rhs) const noException;
        rbool操作符！=（const char * rhs) const noException;
        rbool contains(const std:: string &s, bool case_sensitive = true) const noException;
        rbool empty() const noException;
私有：
友元 struct char_reference ；
友元 struct const_char_reference ；
        void 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() = default ;
 Managed( const Managed&) = delete ;
 托管(托管 &&) = 删除 ;
 Managed& 操作符=( const Managed&) = 删除 ;
 Managed& Operator=(managed&&) = delete ;
        template < typename , typename >
        朋友 struct 托管；
 }；
 
    template <> struct managed<std::optional<std::string>> final : public managed<std::string> {
        using value_type = std::Optional<std::string>;
        运用 managed <std::string>::operator=;
        托管 & 操作符 =(std::Optional<std::string>&& v) { 设立(std::move(v)); return * this ; }
        托管 & 操作符 =( const std::Optional<std::string>& v) { 设立(v); return * this ; }
        Managed & Operator =( const char * v) { set(v); return * this ; }
 
 [[nodiscard]] std::Optional<std::string> 分离() const {
            return m_obj->template get_Optional<std::string>(m_key);
 }
 
 [[nodiscard]] std::Optional<std::string> 操作符 *() const {
            return detach();
 }
 
 [[nodiscard]]操作符std::Optional<std::string>() const {
            return detach();
 }
 
        rbool 操作符==( const std::Optional<std::string>& rhs) const noException ;
        rbool操作符！=( const std::Optional<std::string>& rhs) const noException ;
    private :
        void inline 设立( const std::Optional<std::string>& v) { m_obj->template 设立<std::Optional<std::string>>(m_key, v); }
        托管() = 默认;
        托管 ( const 托管 &) = delete ;
        托管 ( 托管 &&) = delete ;
        托管 & 操作符=( const 托管 &) = delete ;
        托管 & 操作符=( 托管 &&) = delete ;
        template < typename , typename >
        朋友 struct 托管；
 }；
 }
 
#endif //CPREALM_MANAGED_STRING_HPP