box.hpp

Go to the documentation of this file.

#pragma once
#include "collections/generic/helpers/comparer.hpp"
#include "collections/generic/helpers/equator.hpp"
#include "convert_string.hpp"
#include "hash_code.hpp"
#include "icomparable.hpp"
#include "iequatable.hpp"
#include "iequatable.hpp"
#include "iformatable.hpp"
#include "istringable.hpp"
#include "is.hpp"
#include "object.hpp"
#include "string.hpp"
#include "types.hpp"
#include "typeof.hpp"

namespace xtd {
  template<typename type_t>
  struct box : xtd::object, xtd::icomparable<box<type_t>>, xtd::iequatable<box<type_t >>, xtd::iformatable {
    
    using value_type = type_t;
    
    using reference = type_t&;
    
    using const_reference = const type_t&;
    
    using pointer = type_t*;
    
    using const_pointer = const type_t*;
    
    
    box() = default;
    box(const_reference value) : value(value) {}
    template<typename ...args_t>
    box(args_t&& ...args) : value(args...) {}
    
    box(box&&) = default;
    box(const box&) = default;
    box& operator =(box&&) = default;
    box& operator =(const box&) = default;
    box& operator =(const_reference value) {
      this->value = value;
      return *this;
    };
    
    
    value_type value {};
    
    
    operator value_type() const noexcept {return value;}
    
    
    [[nodiscard]] auto compare_to(const box& value) const noexcept -> xtd::int32 override {return xtd::collections::generic::helpers::comparer<value_type> {}(this->value, value.value);}
    
    [[nodiscard]] auto equals(const object& obj) const noexcept -> bool override {return is<box<value_type>>(obj) && equals(static_cast<const box<value_type>& > (obj));}
    [[nodiscard]] auto equals(const box& value) const noexcept -> bool override {return xtd::collections::generic::helpers::equator<value_type> {}(this->value, value.value);}
    
    [[nodiscard]] auto get_hash_code() const noexcept -> xtd::usize override {return hash_code::combine(value);}
    
    [[nodiscard]] auto to_string() const noexcept -> xtd::string override;
    [[nodiscard]] auto to_string(const xtd::string& format) const -> xtd::string;
    [[nodiscard]] auto to_string(const xtd::string& format, const globalization::culture_info& culture) const -> xtd::string override;
    
    friend auto operator << (std::ostream& os, const box& value) -> std::ostream& {return os << value.to_string();}
    
    
    [[nodiscard]] static auto parse(const xtd::string& value) -> value_type {return xtd::parse<value_type>(value);}
    
    [[nodiscard]] static auto try_parse(const xtd::string& value, reference result) noexcept -> bool {return xtd::try_parse<value_type>(value.chars(), result);}
  };
}