Managed_numeric.happ

 
//
// © 2024 Realm Inc.
//
// Apache ライセンス、バージョン 2.0（「ライセンス」）に基づいてライセンスされている
// ライセンス に準拠している場合を除き、このファイルを使用することはできません。
// ライセンスのコピーは次で取得できます:
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// 該当するルールによって要求されたり、書込み (write) で同意された場合を除き、ソフトウェア
ライセンスに基づいて配布される // は "AS IS" CRUD で配布されるため、
// 任意の種類の 保証 または 条件なし（式またはExpressのいずれか）。
// 特定の言語を使用する権限については、「ライセンス」を参照してください
ライセンスに基づく // の制限。
//
 
#ifndef CPPREALM_MANAGED_NUMERIC_HPP
#dedefined CPREALM_MANAGED_NUMERI_HPP
 
#include <cpprealm/macros.hpp>
#include <cpprealm/rbool.hpp>
 
名前空間邦土 {
    template<>
    構造体 Managed <int 64 _t> : Managed_base {
        使用 Managed <int 64 _t>::maned_base::operator==============================================================
 
        マネージド_ベースと演算子 =( const int 64 _t=v) {
 This->m_obj->template set<int 64 _t>(m_key,v)
            この を 返し ます。
 }
 
 [[nodiscard]] int64_t detach() const {
            return m_obj->template get<int64_t>(m_key)
 }
 
 [[nodiscard]] int 64 _t 演算子 *() const {
            return detach();
 }
 
 [[nodiscard]]演算子int 64 _t() const {
            return detach();
 }
 
        テンプレート< typename T>
std:: enable_if_t<T> = std:: is_integral_v =======================================================================================
            場合（この ->m_rbool_query）{
                この->m_rbool_query->equal(m_key,（int 64 _rhs) を返します。
 }
            return Serialize() ==rhs。
 }
 
        テンプレート< typename T>
std:: enable_if_t =std:: is_integral_v<T> =====================================================================T+ rhs ) は {の例外をスローします。
            場合（この ->m_rbool_query）{
                次を返します->m_rbool_query->not_等価（m_key,（int 64 _rhs））
 }
            return Serialize(Delete()) バージョン .= rhs。
 }
 
        テンプレート< typename T>
std:: enable_if_t = std:: is_integral_v ========================================================================<T>
            場合（この ->m_rbool_query）{
                この->m_rbool_query->greater(m_key, (int 64 _rhs) を返します。
 }
            return Serialize(Delete()) >rhs。
 }
 
        テンプレート< typename T>
std:: enable_if_t = std:: is_integral_v ========================================================================<T>
            場合（この ->m_rbool_query）{
                この->m_rbool_query->less(m_key,（int 64 _t)rhs) を返します。
 }
            return Serialize(Delete()) <rhs。
 }
 
        テンプレート< typename T>
std:: enable_if_t = std:: is_integral_v ============================================================================<T>
            場合（この ->m_rbool_query）{
                この->m_rbool_query->greater_equal(m_key,（int 64 _t)rhs) を返します。
 }
            return Serialize(Delete()) >=rhs。
 }
 
        テンプレート< typename T>
std:: enable_if_t<T> = std:: is_integral_v ===========================================================================
            場合（この ->m_rbool_query）{
                これを返すには、->m_rbool_query->less_equal(m_key,（int 64 _rhs) を参照してください。
 }
            return Serialize(Delete()) <= rhs。
 }
 
        Managed & 演算子+=( const int 64 _t=o) {
            auto_val = m_obj->template get<int 64 _t>(m_key)
 m_obj->template set<int 64 _t>(この->m_key, old_val +o)
            この を 返し ます。
 }
        無効演算子 ++( int ) {
            auto_val = m_obj->template get<int 64 _t>(m_key)
 m_obj->template set<int 64 _t>（この->m_key, old_val + 1 ）
 }
        無効演算子 ++() {
            auto_val = m_obj->template get<int 64 _t>(m_key)
 m_obj->template set<int 64 _t>（この->m_key, old_val + 1 ）
 }
        マネージド& 演算子-=( const int 64 _t=o) {
            auto_val = m_obj->template get<int 64 _t>(m_key)
 m_obj->template set<int 64 _t>(search->m_key, old_val-o)
            この を 返し ます。
 }
        無効演算子-( int ) {
            auto_val = m_obj->template get<int 64 _t>(m_key)
 m_obj->template set<int 64 _t>(search->m_key, old_val- 1 )
 }
        無効演算子-() {
            auto_val = m_obj->template get<int 64 _t>(m_key)
 m_obj->template set<int 64 _t>(search->m_key, old_val- 1 )
 }
        マネージド& 演算子*=( const int 64 _t=o) {
            auto_val = m_obj->template get<int 64 _t>(m_key)
 m_obj->template set<int 64 _t>(この->m_key, old_val * op)
            この を 返し ます。
 }
 
    private :
        マネージド（）=デフォルト、
        マネージド（ const administrators ） =削除。
        マネージド（マネージド& ）= delete 。
        Managed & 演算子=( constマネージド&) = delete 。
        Managed & 演算子=(マネージド&と) = delete 。
        テンプレート< typename , typename >
        友人 構造体 マネージド
 };
 
    template<>
    構造体 Managed <double> : Managed_base {
        使用 authorized < double >:: maned_base ::operator============================================
 
        マネージド_ベースと演算子 =( const double & v) {
この ->m_obj->template set<double>(m_key, v)
            この を 返し ます。
 }
 
        Managed_base & 演算子 =( const int & v) {
この->m_obj->template<double> set=double>（m_key,（ double ）v）
            この を 返し ます。
 }
 
[[ nodiscard ]] double Delete() Const {
            return m_obj->template get<double>(m_key) を返します。
 }
 
        double演算子 *()条件{
            return detach();
 }
 [[nodiscard]]演算子double() const {
            return detach();
 }
 
        テンプレート< typename T>
std::enable_if_t<<T> <T>std::disjortion_v[std::is_integral[T]>、std::is_floating_point[T]]、 rbool > 演算子==( const T+rhs) const noException {{
            場合（この ->m_rbool_query）{
                この->m_rbool_query->equal（m_key,（ double ）rhs）を 返し ます。
 }
            return Serialize() ==rhs。
 }
 
        テンプレート< typename T>
std::enable_if_t< std::disjortion_v[std::is_integral[T]],<T> std::is_floating_point[T][] を含む、<T> rbool > 演算子 !=( constT+ rhs ) は {の例外をスローします。
            場合（この ->m_rbool_query）{
                この->m_rbool_query->not_等価（m_key,（ double ）rhs）を 返し ます。
 }
            return Serialize(Delete()) バージョン .= rhs。
 }
 
        テンプレート< typename T>
std::enable_if_t<<T> std::disjortion_v[std::is_integral[T]]、std::is_floating_point[T][]、<T> rbool > 演算子>( const T+rhs) const は例外を除きます。
            場合（この ->m_rbool_query）{
                この->m_rbool_query->greater(m_key,（ double ）rhs）を 返し ます。
 }
            return Serialize(Delete()) >rhs。
 }
 
        テンプレート< typename T>
std::enable_if_t<<T> <T>std::disjortion_v[std::is_integral[T]>、std::is_floating_point[T]]、 rbool > 演算子[（ const T+rhs） const 以外 （{{
            場合（この ->m_rbool_query）{
                この->m_rbool_query->less(m_key,（ double ）rhs）を 返し ます。
 }
            return Serialize(Delete()) <rhs。
 }
 
        テンプレート< typename T>
std::enable_if_t<<T> std::disjortion_v[std::is_integral[T]]、std::is_floating_point[T][]、<T> rbool > 演算子>=( const T+rhs) const noException {{
            場合（この ->m_rbool_query）{
                この->m_rbool_query->greater_equal(m_key,（ double ）rhs）を 返し ます。
 }
            return Serialize(Delete()) >=rhs。
 }
 
        テンプレート< typename T>
std::enable_if_t<<T> std::disjortion_v[std::is_integral[T]]、std::is_floating_point[T][]、<T> rbool > 演算子==( const T+rhs) const noException {{
            場合（この ->m_rbool_query）{
                この上を返します ->m_rbool_query->less_equal(m_key,（ double ）rhs）
 }
            return Serialize(Delete()) <= rhs。
 }
 
        無効演算子+=( const double & op) {
            auto_val = m_obj->template<double> get=double>(m_key)
m_obj->template<double> set=double>（この->m_key、 old_val +o）
 }
        無効演算子 ++( int ) {
            auto_val = m_obj->template<double> get=double>(m_key)
m_obj->template<double> set=double>（この->m_key, old_val +1.0 ）
 }
        無効演算子 ++() {
            auto_val = m_obj->template<double> get=double>(m_key)
m_obj->template<double> set=double>（この->m_key, old_val +1.0 ）
 }
        無効演算子-=( const double & op) {
            auto_val = m_obj->template<double> get=double>(m_key)
 m_obj->template set<double>(この->m_key、 old_val -o)
 }
        無効演算子-( int ) {
            auto_val = m_obj->template<double> get=double>(m_key)
m_obj->template<double> set=double>（この->m_key、 old_val -1.0 ）
 }
        無効演算子-() {
            auto_val = m_obj->template<double> get=double>(m_key)
m_obj->template<double> set=double>（この->m_key、 old_val -1.0 ）
 }
        無効演算子 *=( const double & O) {
            auto_val = m_obj->template<double> get=double>(m_key)
m_obj->template<double> set=double>(この->m_key, old_val * op)
 }
 
    private :
        マネージド（）=デフォルト、
        マネージド（ const administrators ） =削除。
        マネージド（マネージド& ）= delete 。
        Managed & 演算子=( constマネージド&) = delete 。
        Managed & 演算子=(マネージド&と) = delete 。
        テンプレート< typename , typename >
        友人 構造体 マネージド
 };
 
    template<>
    構造体 Managed <bool> : Managed_base {
        使用 authorized < bool >:: maned_base ::operator===================================================================
 
 [[nodiscard]]ブール値デタッチ() const {
            return m_obj->template get<bool>(m_key) を返します。
 }
 [[nodiscard]]演算子bool() const {
            return detach();
 }
        ブール演算子 *()演算子{
            return detach();
 }
 
        rbool 演算子==( constbool &rhs) const は 以外 の 条件 に一致し ます。
        rbool演算子!=( const ブール値とrhs ）は 以外の値ではありません。
 
    private :
        マネージド（）=デフォルト、
        マネージド（ const administrators ） =削除。
        マネージド（マネージド& ）= delete 。
        Managed & 演算子=( constマネージド&) = delete 。
        Managed & 演算子=(マネージド&と) = delete 。
        テンプレート< typename , typename >
        友人 構造体 マネージド
 };
 
CPP_REALM_MANAGED_OPTIONAL_NUMELIC(type) を定義します\
    template<> \
    structmanded=std::optional=type===================================================<type>
        <type>を使用する::maned_base::operator================================================================= $
                                                 \
        Managed <std::optional=type===================================================<type>
            この->m_obj->template set<type>(m_key, v) $
            この を返します。 $
        } \
        \
        Managed=std::optional=type==================================================================<type>
            この->m_obj->template<type> set=type>(m_key, （double）v） $
            この を返します。 $
        } \
                                                 \
        [[nodiscard]] std::optional[type]<type> Delete()const{\
            return m_obj->get_optional<type>(m_key); \
        } \
\
        [[nodiscard]] std::optional[type]<type> 演算子 *()const {\
            return detach(); \
        } \
        [[nodiscard]] 演算子 std::optional[type]() 演算子<type> {\
            return detach(); \
        } \
        rbool Operator==(const std::optional=type========================================================================================= $<type>
        rbool 演算子!=(const <type>ください。 $
        無効演算子+=(const type & op) {\
            auto_val = m_obj->get_optional<type>(m_key) $
            場合（! old_val）{\
スロー std::runtime_error("null 値に対して算術演算を実行できません。" ) $
 }\
m_obj->template<type> set=type>(この->m_key, (* old_val) + op) $
 }\
無効演算子 ++(int) {\
auto old_val = m_obj->get_optional[type](m_key) $<type>
（! old_val）{\ の場合は
 slow std::runtime_error("null 値で算術演算を実行できません。") $
 }\
m_obj->template<type> set=type>(この->m_key, (* old_val) +1 ) $
 }\
無効演算子-=(const type & op) {\
auto old_val = m_obj->get_optional[type](m_key) $<type>
（! old_val）{\ の場合は
 slow std::runtime_error("null 値で算術演算を実行できません。") $
 }\
m_obj->template<type> set=type>(この->m_key, (* old_val) - op) $
 }\
無効演算子-(int) {\
auto old_val = m_obj->get_optional[type](m_key) $<type>
（! old_val）{\ の場合は
 slow std::runtime_error("null 値で算術演算を実行できません。") $
 }\
 m_obj->template set<type>(この->m_key, (* old_val) - 1 ) $
 }\
無効演算子*=(const type+o){{\
auto old_val = m_obj->get_optional[type](m_key) $<type>
（! old_val）{\ の場合は
 slow std::runtime_error("null 値で算術演算を実行できません。") $
 }\
m_obj->template<type> set=type>(この->m_key, (* old_val) * op) $
 }\
無効演算子*（const type & op）{{\
auto old_val = m_obj->get_optional[type](m_key) $<type>
（! old_val）{\ の場合は
 slow std::runtime_error("null 値で算術演算を実行できません。") $
 }\
m_obj->template<type> set=type>(この->m_key, (* old_val) * op) $
 }\
 valid Operator/(const type & op) {\
auto old_val = m_obj->get_optional[type](m_key) $<type>
（! old_val）{\ の場合は
 slow std::runtime_error("null 値で算術演算を実行できません。") $
 }\
 m_obj->template set<type>(この->m_key, (* old_val) / op) $
 }\
 private:\
 managed() = デフォルト。 $
マネージド(constpedmanと)=delete $
マネージド(マネージド & ) = 削除。 $
マネージド() 演算子=(const マネージド() = 削除) $
マネージドと 演算子=(manedおよびを) =削除。 $
 template<typename, typename> \
 MongoDB_ENUS_JAJP $
 }; \
 
 CPP_REALM_MANAGED_OPTIONAL_NUMERI（int 64 _t）
 CCP_REALM_MANAGED_OPTIONAL_NUMBERプライマリ（ double ）
 
    template<>
    構造体 Managed <std:: optional =bool================================================<bool>
        使用 Managed <std::optional=bool=================================================================<bool>
 
[[nodiscard]] std::optional[bool]><bool> Delete() const {
            return m_obj->template get_optional<bool>(m_key);
 }
 
[[nodiscard]] 演算子 std::optional=bool>()<bool> const {
            return m_obj->template get_optional<bool>(m_key);
 }
 
std::optional[]<bool> 演算子 *() Const {
            return detach();
 }
 
        rbool Operator==( const std::optional<bool> = bool ===============================================================================
        rbool演算子!=( const std::optional<bool> = bool ===========================================
 
    private :
        マネージド（）=デフォルト、
        マネージド（ const administrators ） =削除。
        マネージド（マネージド& ）= delete 。
        Managed & 演算子=( constマネージド&) = delete 。
        Managed & 演算子=(マネージド&と) = delete 。
        テンプレート< typename , typename >
        友人 構造体 マネージド
 };
 
    テンプレート< typename T>
    構造体 authorized <T, std:: enable_if_t =std:: is_enum_v<T> ================================================
        Managed <T> & 演算子 =( const T & v) {
 m_obj->template set<int 64 _t>(m_key, static_ Cast < int 64 _t > (v))
            この を 返し ます。
 }
 
 [[ nodiscard ]] T Delete() Const {
            return 静的_ Cast_ T > (m_obj->get_int 64 _t>(m_key))。
 }
 
 [[ nodiscard ]] T 演算子 *() 制約 {
            return detach();
 }
 
 [[nodiscard]]演算子T() const {
            return detach();
 }
 
        //Mask: - 比較演算子
        rbool演算子==( const T{rhs) は { の例外をスローします。
            場合（この ->m_rbool_query）{
                この上を返します ->m_rbool_query->equal（m_key、serialize（rhs））。
 }
            return detach() == rhs;
 }
        rbool演算子!=( const T+ rhs )は{
            場合（この ->m_rbool_query）{
                これを返すには、->m_rbool_query->not_等価（m_key、serialize（rhs））を返します。
 }
            return detach() != rhs;
 }
        rbool 演算子>( const T {rhs) は { を
            場合（この ->m_rbool_query）{
                この->m_rbool_query->greater（m_key、serialize（rhs））を返します。
 }
            return detach() > rhs;
 }
        rbool 演算子 未満（ const T
            場合（この ->m_rbool_query）{
                この->m_rbool_query->greater（m_key、serialize（rhs））を返します。
 }
            return delete() <rhs。
 }
        rbool演算子>=( const T+rhs) const noException {
            場合（この ->m_rbool_query）{
                この上を返します ->m_rbool_query->greater_equal(m_key、serialize(rhs))
 }
            return detach() >= rhs;
 }
        rbool 演算子 == ( const T=rhs) =======================================================================
            場合（この ->m_rbool_query）{
                これを返すには、->m_rbool_query->less_equal（m_key、serialize（rhs））を参照してください。
 }
            return Delete() <= rhs。
 }
 
    private :
        マネージド（）=デフォルト、
        マネージド（ const administrators ） =削除。
        マネージド（マネージド& ）= delete 。
        Managed & 演算子=( constマネージド&) = delete 。
        Managed & 演算子=(マネージド&と) = delete 。
        テンプレート< typename , typename >
        友人 構造体 マネージド
 };
 
    テンプレート< typename T>
    構造体 Managed <std::optional=T>,<T> std:: enable_if_t =std:: is_enum_v ==========================================================<T>
        Managed{std::optional[T] ><T> + 演算子 =( const std::optional+v){{<T>
            （ v ）{
 m_obj- > template set=std::optional=int 64 64 ======================================================================================
 } else {
 m_obj->set_null(m_key);
 }
            この を 返し ます。
 }
 
[[nodiscard]] std::optional[T]<T> Delete() const {
            の場合（ auto v = m_obj->get_optional{int 64 _t>(m_key)) {
                return 静的_キャスト_T > (*v):
 }
            std::nullopt を返す
 }
 
[[nodiscard]] std::optional[T]<T> 演算子 *() const {
            return detach();
 }
 
[[ nodiscard ]] 演算子 std::optional[T]()<T> 演算子 {
            return detach();
 }
 
        //Mask: - 比較演算子
        rbool 演算子==( const std:: optional<T> ==================================================================================
            場合（この ->m_rbool_query）{
                この上を返します ->m_rbool_query->equal（m_key、serialize（rhs））。
 }
            return detach() == rhs;
 }
        rbool演算子!=( const std::optional<T> + rhs ）{{
            場合（この ->m_rbool_query）{
                これを返すには、->m_rbool_query->not_等価（m_key、serialize（rhs））を返します。
 }
            return detach() != rhs;
 }
        rbool 演算子>( const T {rhs) は { を
            場合（この ->m_rbool_query）{
                この->m_rbool_query->greater(m_key、rhs) を返します。
 }
            return detach() > rhs;
 }
        rbool 演算子 未満（ const T
            場合（この ->m_rbool_query）{
                これを返すには、->m_rbool_query->less(m_key、rhs）を返します。
 }
            return delete() <rhs。
 }
        rbool演算子>=( const T+rhs) const noException {
            場合（この ->m_rbool_query）{
                これを返すには、->m_rbool_query->greater_equal(m_key、rhs) を返します。
 }
            return detach() >= rhs;
 }
        rbool 演算子 == ( const T=rhs) =======================================================================
            場合（この ->m_rbool_query）{
                これを返すには、->m_rbool_query->less_equal（m_key、rhs）を返します。
 }
            return Delete() <= rhs。
 }
 
    private :
        マネージド（）=デフォルト、
        マネージド（ const administrators ） =削除。
        マネージド（マネージド& ）= delete 。
        Managed & 演算子=( constマネージド&) = delete 。
        Managed & 演算子=(マネージド&と) = delete 。
        テンプレート< typename , typename >
        友人 構造体 マネージド
 };
} // namespace realm
 
#endif//CPREALM_MANAGED_NUMERI_HPP