managed_string.hpp

 
//
//저작권 2024 Realm Inc.
//
// Apache 라이선스, 버전 2.0("라이선스")에 따라 라이선스가 부여됩니다.
// 라이선스를 준수하는 경우를 제외하고는 이 파일을 사용할 수 없습니다.
// 다음에서 라이선스 사본을 얻을 수 있습니다.
//
// http://www.apache.org/licences/LICENSE-2.0
//
// 관련 법률에서 요구하거나 문서로 동의하지 않는 한, 소프트웨어
// 라이선스에 따라 배포되는 것은 '있는 그대로' 배포됩니다,
// Express 묵시적이든 어떤 종류의 보증이나 조건도 제공하지 않습니다.
// 권한을 관리하는 특정 언어에 대한 내용은 라이선스를 참조하세요.
// 라이선스에 따른 제한 사항.
//
 
#ifndef CPPREALM_MANAGED_STRING_HPP
#define CPPRALM_MANAGED_STRING_HPP
 
#include <cpprealm/macros.hpp>
 
네임스페이스 영역 {
    클래스 rbool;
}
 
네임스페이스 영역 {
    //MARK: - 문자 참조
    구조체 char_reference {
        char_reference& 연산자 =(char c);
    private:
        char_reference(managed<std::string>* parent, size_t idx);
        템플릿 <typename, typename> 친구 구조체 realm::managed;
        친구 구조체 char_pointer;
        managed<std::string>* m_parent;
        size_t m_idx;
 };
    //MARK: - const char 참조
    구조체 const_char_reference {
        연산자 char() const; //NOLINT(google-explicit-constructor)
    private:
        const_char_reference(const managed<std::string>* parent, size_t idx);
        템플릿 <typename, typename> 친구 구조체 realm::managed;
        친구 구조체 const_char_pointer;
        const managed<std::string>* m_parent;
        size_t m_idx;
 };
    //MARK: - 문자 포인터
    구조체 char_pointer {
        char_reference 연산자 [](size_t idx);
    private:
        명시적 char_pointer(managed<std::string>* parent);
        템플릿 <typename, typename> 친구 구조체 realm::managed;
        managed<std::string>* m_parent;
 };
    //MARK: - const char 포인터
    구조체 const_char_pointer {
        const_char_reference 연산자 [](size_t idx) const;
    private:
        명시적 const_char_pointer(const managed<std::string>* parent);
        템플릿 <typename, typename> 친구 구조체 realm::managed;
        const managed<std::string>* m_parent;
 };
 
    //MARK: - managed string
    템플릿 <> struct managed<std::string> : managed_base {
        using value_type = std::string;
        사용 관리되는<std::string>::managed_base::managed_base;
        사용 managed<std::string>::managed_base:: 연산자=;
 
 [[nodiscard]] std::string fetch() const;
 
        사용 reference = char_reference;
        사용 const_reference = const_char_reference;
 
        관리되는& 연산자 =(std::string&& v) { set(std::move(v)); return *this; }
        관리되는& 연산자 =(const std::string& v) { set(v); return *this; }
        관리되는& 연산자 =(const char* v) { set(v); return *this; }
 
        //MARK: - 요소 액세스
        참조 at(size_t idx);
        참조 연산자[](size_t idx);
 
 [[nodiscard]] const_reference 프런트() const;
        참조 프런트();
 [[nodiscard]] const_reference back() const;
        참조 back();
        char_pointer data();
 [[nodiscard]] const_char_pointer data() const;
 
 [[nodiscard]] const_char_pointer c_str() const;
 
        연산자 std::string_view() const = delete;
        연산자 std::string() const;
 
 
 [[nodiscard]] size_t size() const noException;
        //MARK: - 연산
        clear () noException을 무효화합니다.
        push_back (char c);
        managed& append(const std::string&);
        관리되는& 연산자+=(const std::string&);
        'pop_back()'을 무효화 합니다.
 
        //MARK: - 비교 연산자
        rbool operator==(const std::string& rhs) const noException;
        rbool 연산자==(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_critical = true) const noException;
        rbool empty() const noException;
 비공개:
 친구 구조체 char_reference;
 친구 구조체 const_char_reference;
         oid 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() = 기본값;
 managed(const managed&) = delete;
 managed(managed &&) = 삭제;
 managed& 연산자=(const managed&) = 삭제;
 managed& operator=(managed&&) = delete;
        템플릿<typename, typename>
        친구 구조체 managed;
 };
 
    template <> struct managed<std::optional<std::string>> final : public managed<std::string> {
        using value_type = std::optional<std::string>;
        사용 관리되는<std::string>::operator=;
        managed& 연산자 =(std::optional<std::string>&& v) { 설정하다(std::move(v)); return *this; }
        managed& 연산자 =(const std::optional<std::string>& v) { 설정하다(v); return *this; }
        관리되는& 연산자 =(const char* v) { set(v); return *this; }
 
 [[nodiscard]] std::optional<std::string> fetch() const {
            return m_obj-> Template get_optional<std::string>(m_key);
 }
 
 [[nodiscard]] std::optional<std::string> 연산자 *() const {
            return fetch();
 }
 
 [[nodiscard]] 연산자 std::optional<std::string>() const {
            return fetch();
 }
 
        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); }
        managed() = 기본값;
        managed(const managed&) = delete;
        managed ( managed &&) = delete ;
        managed& 연산자=(const managed&) = delete;
        managed& 연산자=(managed&&) = delete;
        템플릿<typename, typename>
        친구 구조체 managed 됨 ;
 };
}
 
#endif //CPPREALM_MANAGED_STRING_HPP