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/__unique_ptr_object_definition.hpp"
#include "internal/__string_definitions.hpp"
#undef __XTD_CORE_INTERNAL__
#include "helpers/throw_helper.hpp"
#include "core_export.hpp"
#include "generic_stream_output.hpp"
#include "iequatable.hpp"
#include "usize.hpp"
#if defined(__xtd__cpp_lib_format)
#include <cassert>
#include <format>
#include <memory>
#endif
#include <type_traits>

namespace xtd {
  class type_object;
  
  class core_export_ object {
  public:
    
    object() = default;
    
    virtual ~object() = default;
    auto operator ==(const object& obj) const noexcept -> bool;
    auto operator !=(const object& obj) const noexcept -> bool;
    
    
    [[nodiscard]] virtual auto equals(const object& obj) const noexcept -> bool;
    
    [[nodiscard]] virtual auto get_hash_code() const noexcept -> xtd::usize;
    
    [[nodiscard]] virtual auto get_type() const noexcept -> type_object;
    
    template<typename object_t>
    [[nodiscard]] auto memberwise_clone() const -> xtd::unique_ptr_object<object_t>;
    
    [[nodiscard]] virtual auto to_string() const -> xtd::string;
    
    
    template<typename object_a_t, typename object_b_t>
    [[nodiscard]] static auto equals(const object_a_t& object_a, const object_b_t& object_b) noexcept -> bool {
      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<typename object_a_t, typename object_b_t>
    [[nodiscard]] static auto reference_equals(const object_a_t& object_a, const object_b_t& object_b) noexcept -> bool {
      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;
    }

  };

  auto operator <<(std::ostream& os, const xtd::object& obj) noexcept -> std::ostream&;
}
 
 
#include "type.hpp"
 
/*
#if defined(__xtd__cpp_lib_format)
template <>
struct std::formatter<xtd::object> : std::formatter<std::string> {
  template<typename object_t, typename 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
*/