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 "invalid_cast_exception.hpp"
#include "iequatable.hpp"
#include "iformatable.hpp"
#include "istringable.hpp"
#include "is.hpp"
#include "enum.hpp"
#include "object.hpp"
#include "string.hpp"
#include "types.hpp"
#include "typeof.hpp"
 
namespace xtd {
  template<class 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<class ...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;}
    
    
    int32 compare_to(const box& value) const noexcept override {return xtd::collections::generic::helpers::comparer<value_type> {}(this->value, value.value);}
 
    bool equals(const object& obj) const noexcept override {return is<box<value_type>>(obj) && equals(static_cast<const box<value_type>&>(obj));}
    bool equals(const box& value) const noexcept override {return xtd::collections::generic::helpers::equator<value_type> {}(this->value, value.value);}
 
    xtd::size get_hash_code() const noexcept override {return hash_code::combine(value);}
 
    xtd::string to_string() const noexcept override {return std::is_integral<value_type>::value || std::is_floating_point<value_type>::value || std::is_enum<type>::value || std::is_pointer<type>::value || std::is_base_of<xtd::istringable, value_type>::value || std::is_base_of<xtd::object, value_type>::value ? xtd::string::format("{}", value) : typeof_<value_type>().full_name();}
    xtd::string to_string(const xtd::string& format) const {return to_string(format, std::locale {});}
    xtd::string to_string(const xtd::string& format, const std::locale& loc) const override {return xtd::string::format(xtd::string::format("{{:{}}}", format), value);}
 
    
    static value_type parse(const xtd::string& value) {return xtd::parse<value_type>(value);}
 
    static bool try_parse(const xtd::string& value, reference result) noexcept {return xtd::try_parse<value_type>(value.chars(), result);}
  };
}