reference_wrapper_object.hpp

Go to the documentation of this file.

#pragma once
#include "helpers/throw_helper.hpp"
#include "hash_code.hpp"
#include "icomparable.hpp"
#include "iequatable.hpp"
#include "null_ptr.hpp"
#include "object.hpp"
#include <optional>
#include <functional>

namespace xtd {
  namespace linq {
    class enumerable;
  }
  
  
  template<class type_t>
  class reference_wrapper_object : public xtd::object, public xtd::icomparable<reference_wrapper_object<type_t>>, public xtd::iequatable<reference_wrapper_object<type_t >> {
  public:
    
    using base_type = std::reference_wrapper<type_t>;
    using type = typename base_type::type;
    using reference_type = typename base_type::type;
    
    
    static const reference_wrapper_object empty;
    
    
    reference_wrapper_object() noexcept = default;
    reference_wrapper_object(xtd::null_ptr null) noexcept {} // Can't be explicit by design.
    template<class value_t>
    reference_wrapper_object(value_t&& value) noexcept : ref_ {value} {} // Can't be explicit by design.
    reference_wrapper_object(reference_wrapper_object& value) noexcept : ref_ {value.ref_} {}
    reference_wrapper_object(const reference_wrapper_object& value) noexcept : ref_ {value.ref_} {}
    reference_wrapper_object(reference_wrapper_object&& value) noexcept : ref_ {std::move(value.ref_)} {}
    template<class value_t>
    reference_wrapper_object(reference_wrapper_object<value_t>& value) noexcept : ref_ {value.ref_} {}
    template<class value_t>
    reference_wrapper_object(const reference_wrapper_object<value_t>& value) noexcept : ref_ {value.ref_} {}
    template<class value_t>
    reference_wrapper_object(reference_wrapper_object<value_t>&& value) noexcept : ref_ {std::move(value.ref_)} {}
    reference_wrapper_object(base_type& value) noexcept : ref_ {value} {}
    reference_wrapper_object(const base_type& value) noexcept : ref_ {value} {}
    reference_wrapper_object(base_type&& value) noexcept : ref_ {std::move(value)} {}
    template<class value_t>
    reference_wrapper_object(std::reference_wrapper<value_t>& value) noexcept : ref_ {value} {}
    template<class value_t>
    reference_wrapper_object(const std::reference_wrapper<value_t>& value) noexcept : ref_ {value} {}
    template<class value_t>
    reference_wrapper_object(std::reference_wrapper<value_t>&& value) noexcept : ref_ {std::move(value)} {}
    
    
    bool is_empty() const noexcept {return !ref_.has_value();}
    
    const base_type& reference() const {
      if (!ref_.has_value()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      return ref_.value();
    }
    const base_type& reference() const  {…}

    base_type& reference() {
      if (!ref_.has_value()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      return ref_.value();
    }
    base_type& reference() {…}

    
    
    int32 compare_to(const reference_wrapper_object& obj) const noexcept override {
      if (!ref_.has_value() && !obj.ref_.has_value()) return 0;
      if (ref_.has_value() && !obj.ref_.has_value()) return 1;
      if (!ref_.has_value() && obj.ref_.has_value()) return -1;
      return &ref_.value().get() < &obj.ref_.value().get() ? -1 : &ref_.value().get() > &obj.ref_.value().get() ? 1 : 0;
    }
    int32 compare_to(const reference_wrapper_object& obj) const noexcept override {…}
    
    bool equals(const xtd::object& value) const noexcept override {return dynamic_cast<const reference_wrapper_object*>(&value) && equals(static_cast<const reference_wrapper_object&>(value));}
    bool equals(const reference_wrapper_object& value) const noexcept override {
      if (!ref_.has_value() && !value.ref_.has_value()) return true;
      if (ref_.has_value() && !value.ref_.has_value()) return false;
      if (!ref_.has_value() && value.ref_.has_value()) return false;
      return &ref_.value().get() == &value.ref_.value().get();
    }
    bool equals(const reference_wrapper_object& value) const noexcept override {…}
    
    type& get() const {
      if (!ref_.has_value()) xtd::helpers::throw_helper::throws(xtd::helpers::exception_case::null_pointer);
      return ref_.value();
    }
    type& get() const  {…}
    
    xtd::size get_hash_code() const noexcept override {return (ref_.has_value() ? xtd::hash_code::combine(&reference()) : 0);}
    
    void reset() noexcept {ref_.reset();}
    template<class value_t>
    void reset(value_t&& value) noexcept {ref_ = value;}
    void reset(xtd::null_ptr null) noexcept {ref_.reset();}
    
    
    void swap(reference_wrapper_object& value) noexcept {std::swap(ref_, value.ref_);}
    
    type_t& to_object() const {return get();}
    
    template<typename target_t>
    target_t to_object() const;
    
    type& to_reference() const {return get();}
    
    template<typename target_t>
    target_t to_reference() const;
    
    xtd::string to_string() const noexcept override;
    
    
    reference_wrapper_object& operator =(const reference_wrapper_object& value) noexcept {
      ref_ = value.ref_;
      return *this;
    }
    reference_wrapper_object& operator =(const reference_wrapper_object& value) noexcept {…}

    reference_wrapper_object& operator =(reference_wrapper_object& value) noexcept {
      ref_ = value.ref_;
      return *this;
    }
    reference_wrapper_object& operator =(reference_wrapper_object& value) noexcept {…}

    reference_wrapper_object& operator =(reference_wrapper_object&& value) noexcept {
      ref_ = std::move(value.ref_);
      return *this;
    }
    reference_wrapper_object& operator =(reference_wrapper_object&& value) noexcept {…}

    template<class value_t>
    reference_wrapper_object& operator =(const reference_wrapper_object<value_t>& value) noexcept {
      ref_ = value.ref_;
      return *this;
    }
    reference_wrapper_object& operator =(const reference_wrapper_object<value_t>& value) noexcept {…}

    template<class value_t>
    reference_wrapper_object& operator =(reference_wrapper_object<value_t>& value) noexcept {
      ref_ = value.ref_;
      return *this;
    }
    reference_wrapper_object& operator =(reference_wrapper_object<value_t>& value) noexcept {…}

    template<class value_t>
    reference_wrapper_object& operator =(reference_wrapper_object<value_t>&& value) noexcept {
      ref_ = std::move(value.ref_);
      return *this;
    }
    reference_wrapper_object& operator =(reference_wrapper_object<value_t>&& value) noexcept {…}

    template<class value_t>
    reference_wrapper_object& operator =(const std::reference_wrapper<value_t>& value) noexcept {
      ref_ = value;
      return *this;
    }
    reference_wrapper_object& operator =(const std::reference_wrapper<value_t>& value) noexcept {…}

    template<class value_t>
    reference_wrapper_object& operator =(std::reference_wrapper<value_t>& value) noexcept {
      ref_ = value;
      return *this;
    }
    reference_wrapper_object& operator =(std::reference_wrapper<value_t>& value) noexcept {…}

    reference_wrapper_object& operator =(const base_type& value) noexcept {
      ref_ = value;
      return *this;
    }
    reference_wrapper_object& operator =(const base_type& value) noexcept {…}

    reference_wrapper_object& operator =(base_type& value) noexcept {
      ref_ = value;
      return *this;
    }
    reference_wrapper_object& operator =(base_type& value) noexcept {…}

    template<class value_t>
    reference_wrapper_object& operator =(value_t&& value) noexcept {
      ref_ = value;
      return *this;
    }
    reference_wrapper_object& operator =(value_t&& value) noexcept {…}
    
    operator type& () const {return get();}
    
    explicit operator bool() const noexcept {return ref_.has_value();}
    
    friend bool operator ==(const reference_wrapper_object& lhs, const type_t& rhs) noexcept {return lhs.equals(rhs);}
    friend bool operator !=(const reference_wrapper_object& lhs, const type_t& rhs) noexcept {return !lhs.equals(rhs);}
    
    friend std::strong_ordering operator <=>(const reference_wrapper_object& lhs, const type_t& rhs) noexcept {
      auto rhs_ptr = &rhs;
      if (dynamic_cast<const type_t*>(rhs_ptr) && lhs.compare_to(static_cast<const type_t&>(rhs)) < 0) return std::strong_ordering::less;
      if (dynamic_cast<const type_t*>(rhs_ptr) && lhs.compare_to(static_cast<const type_t&>(rhs)) > 0) return std::strong_ordering::greater;
      if (dynamic_cast<const type_t*>(rhs_ptr) && lhs.compare_to(static_cast<const type_t&>(rhs)) == 0) return std::strong_ordering::equivalent;
      return std::strong_ordering::less;
    }
    friend std::strong_ordering operator <=>(const reference_wrapper_object& lhs, const type_t& rhs) noexcept {…}

    
  private:
    template<class other_t>
    friend class reference_wrapper_object;
    std::optional<base_type> ref_;
  };
  class reference_wrapper_object : public xtd::object, public xtd::icomparable<reference_wrapper_object<type_t>>, public xtd::iequatable<reference_wrapper_object<type_t >> {…};
  
  template<class type_t>
  inline const reference_wrapper_object<type_t>  reference_wrapper_object<type_t>::empty;
  
  // C++17 deduction guides for xtd::reference_wrapper_object
  // {
  template<class type_t>
  reference_wrapper_object(type_t&) -> reference_wrapper_object<type_t>;
  // }
}