managed_timestamp.hpp

 
//
// Autores 2022 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_TIMESTAMP_HPP
#define CPPREALM_MANAGED_TIMESTAMP_HPP
 
#include <cpprealm/internal/bridge/timestamp.hpp>
#include <cprealm/macros.hpp>
 
namespace Realm {
    classe rbool;
}
namespace Realm {
 
    modelo<>
    estrutura, estrutura managed<std::chrono::time_point<std::chrono::system_clock>> : public managed_base {
        usando value_type = std::chrono::time_point;<std::chrono::system_clock>
        Usando gerenciado<std::chrono::time_point<std::chrono::system_clock>>::managed_base::operator=;
 
 [[nodiscard]] std::chrono::time_point<std::chrono::system_clock> detach() const {
            return m_obj->template get<realm::internal::bridge::timestamp>(m_key);
 }
 
 [[nodiscard]] operador std::chrono::time_point<std::chrono::system_clock>() const {
            return desvincular();
 }
 
        auto time_since_epach() const {
            auto Typescript = m_obj->template get<internal::bridge::timestamp>(m_key);
            return ts.get_time_point().time_since_epach();
 }
 
        template <typename S>
        operador nulo +=(const std::chrono::duração<S>& rhs) {
            auto Typescript = m_obj->template get<internal::bridge::timestamp>(m_key);
 m_obj->set(m_key, internal::bridge::timestamp(ts.get_time_point() + rhs));
 }
 
        //Marca: - operadores de comparação
        rbool operator==(const std::chrono::time_point<std::chrono::system_clock>& rhs) const noexceto;
        operador de rbool !=(const std::chrono::time_point<std::chrono::system_clock>& rhs) const noexceto;
        Operador de rbool >(const std::chrono::time_point<std::chrono::system_clock>& rhs) const noexceto;
        rbool operator>=(const std::chrono::time_point<std::chrono::system_clock>& rhs) const noexceto;
        operador de rbool <(const std::chrono::time_point<std::chrono::system_clock>& rhs) const noexceto;
        operador derbool <=( const std::chrono::time_point<std::chrono::system_clock>& rhs) const noexceto;
 
    privado:
        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;
 };
 
    modelo<>
    estrutura, estrutura managed<std::optional<std::chrono::time_point<std::chrono::system_clock>>> : managed_base {
        usando value_type = std::opcional<std::chrono::time_point<std::chrono::system_clock>>;
        Usando gerenciado<std::opcional<std::chrono::time_point<std::chrono::system_clock>>>::managed_base::operator=;
 
 [[nodiscard]] std::optional<std::chrono::time_point<std::chrono::system_clock>> detach() const {
            return m_obj->get_optional<realm::internal::bridge::timestamp>(m_key);
 }
 
 [[nodiscard]] operator std::optional<std::chrono::time_point<std::chrono::system_clock>>() const {
            return desvincular();
 }
 
        estrutura, estrutura caixa {
            template <typename S>
            operador nulo +=(const std::chrono::duração<S>& rhs) {
                auto Typescript = m_parent.get().m_obj->get_optional<internal::bridge::timestamp>(m_parent.get().m_key);
 m_parent.get().m_obj->set(m_parent.get().m_key, internal::bridge::timestamp(ts->get_time_point() + rhs));
 }
            auto time_since_epach() const {
                auto Typescript = m_parent.get().m_obj->get_optional<internal::bridge::timestamp>(m_parent.get().m_key);
                return ts->get_time_point().time_since_epoch();
 }
        privado:
            caixa(managed& parent) : m_parent(parent) { }
 std::reference_wraoper<std::chrono::system_clock>
            amigo estrutura, estrutura gerenciado<std::opcional<std::chrono::time_point<std::chrono::system_clock>>>;
 };
 
 std::unique_ptr<box> operator->()
 {
            return std::make_unique<box>(box(*this));
 }
 [[nodiscard]] operador de caixa *() {
            Método caixa(*esta);
 }
 
        //Marca: - operadores de comparação
        rbool operator==(const std::opcional<std::chrono::time_point<std::chrono::system_clock>>& rhs) const noexceto;
        operador de rbool !=(const std::optional<std::chrono::time_point<std::chrono::system_clock>>& rhs) const noexceto;
 
    privado:
        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;
 };
 
} // namespace realm
 
 
#endif//CPPrealm_MANAGED_TIMESTAMP_HPP