optional.h

Go to the documentation of this file.

#ifndef DMLC_OPTIONAL_H_
#define DMLC_OPTIONAL_H_

#include <iostream>
#include <string>
#include <utility>
#include <algorithm>

#include "./base.h"
#include "./common.h"
#include "./logging.h"
#include "./type_traits.h"

namespace dmlc {

struct nullopt_t {
#if defined(_MSC_VER) && _MSC_VER < 1900

  explicit nullopt_t(int a) {}
#else

  constexpr explicit nullopt_t(int a) {}
#endif
};

constexpr const nullopt_t nullopt = nullopt_t(0);

template<typename T>
class optional {
 public:
  optional() : is_none(true) {}
  explicit optional(const T& value) {
#pragma GCC diagnostic push
#if __GNUC__ >= 6
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
    is_none = false;
    new (&val) T(value);
#pragma GCC diagnostic pop
  }
  optional(const optional<T>& other) {
#pragma GCC diagnostic push
#if __GNUC__ >= 6
#pragma GCC diagnostic ignored "-Wmaybe-uninitialized"
#endif
    is_none = other.is_none;
    if (!is_none) {
      new (&val) T(other.value());
    }
#pragma GCC diagnostic pop
  }
  ~optional() {
    if (!is_none) {
      reinterpret_cast<T*>(&val)->~T();
    }
  }
  void swap(optional<T>& other) {
    std::swap(val, other.val);
    std::swap(is_none, other.is_none);
  }
  optional<T>& operator=(const T& value) {
    (optional<T>(value)).swap(*this);
    return *this;
  }
  optional<T>& operator=(const optional<T> &other) {
    (optional<T>(other)).swap(*this);
    return *this;
  }
  optional<T>& operator=(nullopt_t) {
    (optional<T>()).swap(*this);
    return *this;
  }
  T& operator*() {  // NOLINT(*)
    return *reinterpret_cast<T*>(&val);
  }
  const T& operator*() const {
    return *reinterpret_cast<const T*>(&val);
  }
  bool operator==(const optional<T>& other) const {
    return this->is_none == other.is_none &&
           (this->is_none == true || this->value() == other.value());
  }
  const T& value() const {
    if (is_none) {
      throw std::logic_error("bad optional access");
    }
    return *reinterpret_cast<const T*>(&val);
  }
  explicit operator bool() const { return !is_none; }
  bool has_value() const { return operator bool(); }

 private:
  // whether this is none
  bool is_none;
  // on stack storage of value
  typename std::aligned_storage<sizeof(T), alignof(T)>::type val;
};

template<typename T>
std::ostream &operator<<(std::ostream &os, const optional<T> &t) {
  if (t) {
    os << *t;
  } else {
    os << "None";
  }
  return os;
}

template<typename T>
std::istream &operator>>(std::istream &is, optional<T> &t) {
  char buf[4];
  std::streampos origin = is.tellg();
  is.read(buf, 4);
  if (is.fail() || buf[0] != 'N' || buf[1] != 'o' ||
      buf[2] != 'n' || buf[3] != 'e') {
    is.clear();
    is.seekg(origin);
    T x;
    is >> x;
    t = x;
    if (std::is_integral<T>::value && !is.eof() && is.peek() == 'L') is.get();
  } else {
    t = nullopt;
  }
  return is;
}
inline std::istream &operator>>(std::istream &is, optional<bool> &t) {
  // Discard initial whitespace
  while (isspace(is.peek()))
    is.get();
  // Extract chars that might be valid into a separate string, stopping
  // on whitespace or other non-alphanumerics such as ",)]".
  std::string s;
  while (isalnum(is.peek()))
    s.push_back(is.get());

  if (!is.fail()) {
    std::transform(s.begin(), s.end(), s.begin(), ::tolower);
    if (s == "1" || s == "true")
      t = true;
    else if (s == "0" || s == "false")
      t = false;
    else if (s == "none")
      t = nullopt;
    else
      is.setstate(std::ios::failbit);
  }

  return is;
}

DMLC_DECLARE_TYPE_NAME(optional<int>, "int or None");
DMLC_DECLARE_TYPE_NAME(optional<bool>, "boolean or None");
DMLC_DECLARE_TYPE_NAME(optional<float>, "float or None");
DMLC_DECLARE_TYPE_NAME(optional<double>, "double or None");

}  // namespace dmlc

namespace std {
template<typename T>
struct hash<dmlc::optional<T> > {
  size_t operator()(const dmlc::optional<T>& val) const {
    std::hash<bool> hash_bool;
    size_t res = hash_bool(val.has_value());
    if (val.has_value()) {
      res = dmlc::HashCombine(res, val.value());
    }
    return res;
  }
};
}  // namespace std

#endif  // DMLC_OPTIONAL_H_