box.h

Go to the documentation of this file.

 
#pragma once
#include "convert_string.h"
#include "icomparable.h"
#include "iequatable.h"
#include "invalid_cast_exception.h"
#include "iequatable.h"
#include "enum.h"
#include "object.h"
#include "ustring.h"
#include "types.h"
 
namespace xtd {
  template<typename type_t>
  class box : public xtd::icomparable<box<type_t>>, public xtd::iequatable<box<type_t>>, public xtd::object {
  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_;}
    
    
    bool equals(const box& value) const noexcept override {return value_ == value.value_;}
    
    int32 compare_to(const box& value) const noexcept override {
      if (value_ == value.value_) return 0;
      if (value_ < value.value_) return -1;
      return 1;
    }
    
    xtd::ustring to_string() const noexcept override {return xtd::ustring::format("{}", value_);}
    xtd::ustring to_string(const xtd::ustring& format) const noexcept {
      return xtd::ustring::format(xtd::ustring::format("{{:{}}}", format), value_);
    }
 
    
    static type_t parse(const xtd::ustring& value) {return xtd::parse<type_t>(value);}
 
    static bool try_parse(const xtd::ustring& value, type_t& result) noexcept {return xtd::try_parse<type_t>(value, result);}
    
  private:
    type_t value_ {};
  };
}