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 "icomparable.hpp"
#include "iequatable.hpp"
#include "invalid_cast_exception.hpp"
#include "iequatable.hpp"
#include "iformatable.hpp"
#include "is.hpp"
#include "enum.hpp"
#include "object.hpp"
#include "string.hpp"
#include "types.hpp"
 
namespace xtd {
  template<typename type_t>
  class box : public xtd::object, public xtd::icomparable<box<type_t>>, public xtd::iequatable<box<type_t>>, public xtd::iformatable {
  public:
    using underlying_type = type_t;
    
    box() = default;
    box(const type_t& value) : value_(value) {}
    template<typename ...args_t>
    box(args_t&& ...args) : value_(args...) {}
    
    box(const box&) = default;
    box(box&&) = default;
    box& operator =(const box&) = default;
    box& operator =(const type_t& value) {
      value_ = value;
      return *this;
    };
    
    
    const type_t& value() const noexcept {return value_;}
    type_t& value() noexcept {return value_;}
    box& value(const type_t& value) {
      value_ = value;
      return *this;
    }
    
    
    operator type_t() const noexcept {return value_;}
    
    
    int32 compare_to(const box& value) const noexcept override {return equals(value) ? 0 : xtd::collections::generic::helpers::comparer<type_t> {}(value_, value.value_) ? -1 : 1;}
    bool equals(const object& obj) const noexcept override {return is<box<type_t>>(obj) && equals(static_cast<const box<type_t>&>(obj));}
    bool equals(const box& value) const noexcept override {return xtd::collections::generic::helpers::equator<type_t> {}(value_, value.value_);}
    xtd::string to_string() const noexcept override {return std::is_integral<type_t>::value || std::is_floating_point<type_t>::value || std::is_enum<type>::value || std::is_pointer<type>::value || std::is_base_of<xtd::object, type_t>::value ? xtd::string::format("{}", value_) : typeof_<type_t>().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 type_t parse(const xtd::string& value) {return xtd::parse<type_t>(value);}
 
    static bool try_parse(const xtd::string& value, type_t& result) noexcept {return xtd::try_parse<type_t>(value.chars(), result);}
    
  private:
    type_t value_ {};
  };
}