object.hpp

Go to the documentation of this file.

 
#pragma once
 
#define __XTD_STD_INTERNAL__
#include "internal/__xtd_std_version.hpp"
#undef __XTD_STD_INTERNAL__
#define __XTD_CORE_INTERNAL__
#include "internal/__string_definitions.hpp"
#undef __XTD_CORE_INTERNAL__
#include "helpers/throw_helper.hpp"
#include "core_export.hpp"
#include "iequatable.hpp"
#include "ptr.hpp"
#include "types.hpp"
#if defined(__xtd__cpp_lib_format)
#include <cassert>
#include <format>
#endif
#include <type_traits>
 
namespace xtd {
  class type_object;
  
  class core_export_ object {
  public:
    
    object() = default;
    
    object(const object&) = default;
    object& operator =(const object&) = default;
    virtual ~object() = default;
    bool operator ==(const object& obj) const noexcept;
    bool operator !=(const object& obj) const noexcept;
    
    
    virtual bool equals(const object& obj) const noexcept;
    
    virtual xtd::size get_hash_code() const noexcept;
    
    virtual type_object get_type() const noexcept;
    
    template<class object_t>
    xtd::uptr<object_t> memberwise_clone() const {
      auto object_ptr = dynamic_cast<const object_t*>(this);
      if (object_ptr == nullptr) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::invalid_cast);
      return xtd::new_uptr<object_t>(*object_ptr);
    }
    
    virtual xtd::string to_string() const noexcept;
    
    
    template<class object_a_t, class object_b_t>
    static bool equals(const object_a_t& object_a, const object_b_t& object_b) noexcept {
      static_assert(std::is_base_of<xtd::object, object_a_t>::value, "object_a does not inherit from xtd::object");
      static_assert(std::is_base_of<xtd::object, object_b_t>::value, "object_b does not inherit from xtd::object");
      return object_a == object_b;
    }
 
    template<class object_a_t, class object_b_t>
    static bool reference_equals(const object_a_t& object_a, const object_b_t& object_b) noexcept {
      static_assert(std::is_base_of<xtd::object, object_a_t>::value, "object_a does not inherit from xtd::object");
      static_assert(std::is_base_of<xtd::object, object_b_t>::value, "object_b does not inherit from xtd::object");
      return &object_a == &object_b;
    }
  };
}
 
std::ostream& operator <<(std::ostream& os, const xtd::object& obj) noexcept;
 
#include "type.hpp"
 
/*
#if defined(__xtd__cpp_lib_format)
template <>
struct std::formatter<xtd::object> : std::formatter<std::string> {
  template<class object_t, class format_context_t>
  auto format(const object_t& obj, format_context_t& ctx) const {return std::format_to(ctx.out(), "{}", std::string {obj.to_string()});}
};
#endif
*/