// Copyright 2016 Glyn Matthews.
// Copyright (C) 2011 - 2012 Andrzej Krzemienski.
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)

/**
* \file
* \brief Contains an implementation of C++17 optional (n3793).
*
* \sa https://github.com/akrzemi1/Optional
* \sa http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n3848.html
*/

#ifndef NETWORK_OPTIONAL_INC
#define NETWORK_OPTIONAL_INC

#include <stdexcept>
#include <type_traits>
#include <utility>
#include <memory>
#include <algorithm>

#if !defined(DOXYGEN_SHOULD_SKIP_THIS)
#ifdef NDEBUG
#define NETWORK_ASSERTED_EXPRESSION(CHECK, EXPR) (EXPR)
#else
#define NETWORK_ASSERTED_EXPRESSION(CHECK, EXPR) \
 ((CHECK) ? (EXPR) : (fail(#CHECK, __FILE__, __LINE__), (EXPR)))
inline void fail(const char *, const char *, unsigned) {}
#endif  // NDEBUG
#endif  // !defined(DOXYGEN_SHOULD_SKIP_THIS)

namespace network {
/**
* \ingroup optional
* \class nullopt_t optional.hpp network/uri.hpp
* \brief Disengaged state indicator.
* \sa optional
*/
struct nullopt_t {
#if !defined(DOXYGEN_SHOULD_SKIP_THIS)
 struct init {};
 constexpr nullopt_t(init) {}
#endif  // !defined(DOXYGEN_SHOULD_SKIP_THIS)
};

/**
* \ingroup optional
* \brief Used to indicate a *disengaged* state for optional objects.
*/
constexpr nullopt_t nullopt{nullopt_t::init{}};

/**
* \ingroup optional
* \class bad_optional_access optional.hpp network/uri.hpp
* \brief Exception thrown when the value member function is called when the
*        optional object is disengaged.
*/
class bad_optional_access : public std::logic_error {
public:
 /**
  * \brief Constructor.
  * \param what_arg The error message.
  */
 explicit bad_optional_access(const std::string &what_arg)
     : std::logic_error(what_arg) {}

 /**
  * \brief Constructor.
  * \param what_arg The error message.
  */
 explicit bad_optional_access(const char *what_arg)
     : std::logic_error(what_arg) {}
};

#if !defined(DOXYGEN_SHOULD_SKIP_THIS)
namespace details {
struct dummy_t {};

template <class T>
union trivially_destructible_optional_storage {
 static_assert(std::is_trivially_destructible<T>::value, "");

 dummy_t dummy_;
 T value_;

 constexpr trivially_destructible_optional_storage() : dummy_{} {}

 constexpr trivially_destructible_optional_storage(const T &v) : value_{v} {}

 ~trivially_destructible_optional_storage() = default;
};

template <class T>
union optional_storage {
 dummy_t dummy_;
 T value_;

 constexpr optional_storage() : dummy_{} {}

 constexpr optional_storage(const T &v) : value_{v} {}

 ~optional_storage() {}
};

template <class T>
class trivially_destructible_optional_base {
public:
 typedef T value_type;

 constexpr trivially_destructible_optional_base() noexcept
     : init_(false), storage_{} {}

 constexpr trivially_destructible_optional_base(const T &v)
     : init_(true), storage_{v} {}

 constexpr trivially_destructible_optional_base(T &&v)
     : init_(true), storage_{std::move(v)} {}

 ~trivially_destructible_optional_base() = default;

protected:
 bool init_;
 optional_storage<T> storage_;
};

template <class T>
class optional_base {
public:
 typedef T value_type;

 constexpr optional_base() noexcept : init_(false), storage_{} {}

 constexpr optional_base(const T &v) : init_(true), storage_{v} {}

 constexpr optional_base(T &&v) : init_(true), storage_{std::move(v)} {}

 ~optional_base() {
   if (init_) {
     storage_.value_.T::~T();
   }
 }

protected:
 bool init_;
 optional_storage<T> storage_;
};
}  // namespace details
#endif  // !defined(DOXYGEN_SHOULD_SKIP_THIS)

/**
* \ingroup optional
* \class optional optional.hpp network/uri.hpp
* \brief An implementation of C++17 optional (n3793)
*/
#if !defined(DOXYGEN_SHOULD_SKIP_THIS)
template <class T>
using optional_base =
   typename std::conditional<std::is_trivially_destructible<T>::value,
                             details::trivially_destructible_optional_base<T>,
                             details::optional_base<T>>::type;
#endif  // !defined(DOXYGEN_SHOULD_SKIP_THIS)

template <class T>
#if !defined(DOXYGEN_SHOULD_SKIP_THIS)
class optional : optional_base<T> {
#else
class optional {
#endif  // !defined(DOXYGEN_SHOULD_SKIP_THIS)
 typedef optional_base<T> base_type;

public:
 /**
  * \brief Optional value type.
  */
 typedef T value_type;

 /**
  * \brief Constructor.
  * \post *disengaged*.
  */
 constexpr optional() : optional_base<T>() {}

 /**
  * \brief Constructor.
  * \post *disengaged*.
  */
 constexpr optional(nullopt_t) noexcept : optional_base<T>() {}

 /**
  * \brief Copy constructor.
  * \param other The other optional object.
  */
 optional(const optional &other) {
   if (other) {
     ::new (static_cast<void *>(ptr())) T(*other);
     base_type::init_ = true;
   }
 }

 /**
  * \brief Move constructor.
  * \param other The other optional object.
  */
 optional(optional &&other) noexcept {
   if (other) {
     ::new (static_cast<void *>(ptr())) T(std::move(other.storage_.value_));
     base_type::init_ = true;
   }
 }

 /**
  * \brief Constructor.
  * \param value The value with which to initialize the optional object.
  * \post *engaged*
  */
 constexpr optional(const T &value) : optional_base<T>(value) {}

 /**
  * \brief Constructor.
  * \param value The value with which to initialize the optional object.
  * \post *engaged*
  */
 constexpr optional(T &&value) : optional_base<T>(std::move(value)) {}

 /**
  * \brief Assignment operator.
  * \post *disengaged*.
  * \returns \c *this.
  */
 optional &operator=(nullopt_t) noexcept {
   if (base_type::init_) {
     ptr()->T::~T();
   }
   base_type::init_ = false;
   return *this;
 }

 /**
  * \brief Copy assignment operator.
  * \param other The other optional object.
  * \returns \c *this.
  */
 optional &operator=(const optional &other) {
   if (bool(*this) && !other) {
     ptr()->T::~T();
     base_type::init_ = false;
   } else if (!(*this) && bool(other)) {
     ::new (static_cast<void *>(ptr())) T(*other);
     base_type::init_ = true;
   } else if (bool(*this) && bool(other)) {
     base_type::storage_.value_ = *other;
   }
   return *this;
 }

 /**
  * \brief Move assignment operator.
  * \param other The other optional object.
  * \returns \c *this.
  */
 optional &operator=(optional &&other) noexcept {
   if (bool(*this) && !other) {
     ptr()->T::~T();
     base_type::init_ = false;
   } else if (!(*this) && bool(other)) {
     ::new (static_cast<void *>(ptr())) T(std::move(*other));
     base_type::init_ = true;
   } else if (bool(*this) && bool(other)) {
     base_type::storage_.value_ = std::move(*other);
   }
   return *this;
 }

 /**
  * \brief Destructor.
  */
 ~optional() = default;

 /**
  * \brief Swap function.
  * \param other The other optional object.
  */
 void swap(optional &other) noexcept {
   if (bool(*this) && !other) {
     ::new (static_cast<void *>(other.ptr())) T(std::move(**this));
     ptr()->T::~T();
     std::swap(base_type::init_, other.base_type::init_);
   } else if (!(*this) && bool(other)) {
     ::new (static_cast<void *>(ptr())) T(std::move(*other));
     other.ptr()->T::~T();
     std::swap(base_type::init_, other.init_);
   } else if (bool(*this) && bool(other)) {
     std::swap(**this, *other);
   }
 }

 /**
  * \brief Observer.
  * \pre *engaged*
  * \returns The underlying optional value.
  */
 constexpr T const *operator->() const {
   return NETWORK_ASSERTED_EXPRESSION(bool(*this), ptr());
 }

 /**
  * \brief Observer.
  * \pre *engaged*
  * \returns The underlying optional value.
  */
 T *operator->() { return NETWORK_ASSERTED_EXPRESSION(bool(*this), ptr()); }

 /**
  * \brief Observer.
  * \pre *engaged*
  * \returns The underlying optional value.
  */
 constexpr T const &operator*() const {
   return NETWORK_ASSERTED_EXPRESSION(bool(*this), base_type::storage_.value_);
 }

 /**
  * \brief Observer.
  * \pre *engaged*
  * \returns The underlying optional value.
  */
 T &operator*() {
   return NETWORK_ASSERTED_EXPRESSION(bool(*this), base_type::storage_.value_);
 }

 /**
  * \brief Operator bool overloads.
  * \returns \c true if the optional is *engaged*, \c false if it is
  * *disengaged*.
  */
 constexpr explicit operator bool() const noexcept { return base_type::init_; }

 /**
  * \returns The underlying optional value, if \c bool(*this).
  * \throws A bad_optional_access if \c !*this.
  */
 constexpr T const &value() const {
   return *this ? base_type::storage_.value_
                : (throw bad_optional_access("Uninitialized optional value"),
                   base_type::storage_.value_);
 }
 /**
  * \returns The underlying optional value, if \c bool(*this).
  * \throws A bad_optional_access if \c !*this.
  */
 T &value() {
   return *this ? base_type::storage_.value_
                : (throw bad_optional_access("Uninitialized optional value"),
                   base_type::storage_.value_);
 }

 /**
  * \returns <tt>bool(*this) ? **this :
  * static_cast<T>(std::forward<U>(v))</tt>. \pre \c
  * <tt>std::is_copy_constructible<T>::value</tt> is \c true and
  * <tt>std::is_convertible<U&&, T>::value</tt> is \c true.
  */
 template <class U>
 T value_or(U &&other) const & {
   static_assert(std::is_copy_constructible<value_type>::value,
                 "Must be copy constructible.");
   static_assert(std::is_convertible<U, value_type>::value,
                 "U must be convertible to T.");
   return bool(*this) ? **this : static_cast<T>(std::forward<U>(other));
 }

 /**
  * \returns <tt>bool(*this) ? std::move(**this) :
  * static_cast<T>(std::forward<U>(v))</tt>. \pre
  * <tt>std::is_move_constructible<T>::value</tt> is \c true and
  * <tt>std::is_convertible<U&&, T>::value</tt> is \c true.
  */
 template <class U>
 T value_or(U &&other) && {
   static_assert(std::is_copy_constructible<value_type>::value,
                 "Must be copy constructible.");
   static_assert(std::is_convertible<U, value_type>::value,
                 "U must be convertible to T.");
   return bool(*this) ? std::move(**this)
                      : static_cast<T>(std::forward<U>(other));
 }

private:
 T *ptr() { return std::addressof(base_type::storage_.value_); }
};

/**
* \brief Equality operator.
*/
template <class T>
bool operator==(const optional<T> &lhs, const optional<T> &rhs) {
 if (bool(lhs) != bool(rhs)) {
   return false;
 } else if (!bool(lhs)) {
   return true;
 } else {
   return *lhs == *rhs;
 }
}

/**
* \brief Inequality operator.
*/
template <class T>
bool operator!=(const optional<T> &lhs, const optional<T> &rhs) {
 return !(lhs == rhs);
}

/**
* \brief Comparison operator.
*/
template <class T>
bool operator<(const optional<T> &lhs, const optional<T> &rhs) {
 if (!rhs) {
   return false;
 } else if (!lhs) {
   return true;
 } else {
   return *lhs < *rhs;
 }
}

/**
* \brief Comparison operator.
* \returns <tt>rhs < lhs</tt>.
*/
template <class T>
bool operator>(const optional<T> &lhs, const optional<T> &rhs) {
 return rhs < lhs;
}

/**
* \brief Comparison operator.
* \returns <tt>!(rhs < lhs)</tt>.
*/
template <class T>
bool operator<=(const optional<T> &lhs, const optional<T> &rhs) {
 return !(rhs < lhs);
}

/**
* \brief Comparison operator.
* \returns <tt>!(rhs > lhs)</tt>.
*/
template <class T>
bool operator>=(const optional<T> &lhs, const optional<T> &rhs) {
 return !(lhs < rhs);
}

/**
* \brief Equality operator.
* \returns \c !x.
*/
template <class T>
bool operator==(const optional<T> &x, nullopt_t) noexcept {
 return !x;
}

/**
* \brief Equality operator.
* \returns \c !x.
*/
template <class T>
bool operator==(nullopt_t, const optional<T> &x) noexcept {
 return !x;
}

/**
* \brief Inequality operator.
* \returns \c bool(x).
*/
template <class T>
bool operator!=(const optional<T> &x, nullopt_t) noexcept {
 return bool(x);
}

/**
* \brief Inequality operator.
* \returns \c bool(x).
*/
template <class T>
bool operator!=(nullopt_t, const optional<T> &x) noexcept {
 return bool(x);
}

/**
* \brief Comparison operator.
* \returns \c false.
*/
template <class T>
bool operator<(const optional<T> &x, nullopt_t) noexcept {
 return false;
}

/**
* \brief Comparison operator.
* \returns \c bool(x).
*/
template <class T>
bool operator<(nullopt_t, const optional<T> &x) noexcept {
 return bool(x);
}

/**
* \brief Comparison operator.
* \returns \c !x.
*/
template <class T>
bool operator<=(const optional<T> &x, nullopt_t) noexcept {
 return !x;
}

/**
* \brief Comparison operator.
* \returns \c true.
*/
template <class T>
bool operator<=(nullopt_t, const optional<T> &x) noexcept {
 return true;
}

/**
* \brief Comparison operator.
* \returns \c bool(x).
*/
template <class T>
bool operator>(const optional<T> &x, nullopt_t) noexcept {
 return bool(x);
}

/**
* \brief Comparison operator.
* \returns \c false.
*/
template <class T>
bool operator>(nullopt_t, const optional<T> &x) noexcept {
 return false;
}

/**
* \brief Comparison operator.
* \returns \c true.
*/
template <class T>
bool operator>=(const optional<T> &x, nullopt_t) noexcept {
 return true;
}

/**
* \brief Comparison operator.
* \returns \c !x.
*/
template <class T>
bool operator>=(nullopt_t, const optional<T> &x) noexcept {
 return !x;
}

/**
* \brief Equality operator.
* \returns <tt>bool(x) ? *x == v : false</tt>.
*/
template <class T>
bool operator==(const optional<T> &x, const T &v) {
 return bool(x) ? *x == v : false;
}

/**
* \brief Equality operator.
* \returns <tt>bool(x) ? v == *x : false</tt>.
*/
template <class T>
bool operator==(const T &v, const optional<T> &x) {
 return bool(x) ? v == *x : false;
}

/**
* \brief Inequality operator.
* \returns <tt>bool(x) ? !(*x == v) : true</tt>.
*/
template <class T>
bool operator!=(const optional<T> &x, const T &v) {
 return bool(x) ? !(*x == v) : true;
}

/**
* \brief Inequality operator.
* \returns <tt>bool(x) ? !(v == *x) : true</tt>.
*/
template <class T>
bool operator!=(const T &v, const optional<T> &x) {
 return bool(x) ? !(v == *x) : true;
}

/**
* \brief Comparison operator.
* \returns <tt>bool(x) ? *x < v : true</tt>.
*/
template <class T>
bool operator<(const optional<T> &x, const T &v) {
 return bool(x) ? *x < v : true;
}

/**
* \brief Comparison operator.
* \returns <tt>bool(x) ? v < *x : false</tt>.
*/
template <class T>
bool operator<(const T &v, const optional<T> &x) {
 return bool(x) ? v < *x : false;
}

/**
* \brief Comparison operator.
* \returns <tt>bool(x) ? *x < v : true</tt>.
*/
template <class T>
bool operator>(const optional<T> &x, const T &v) {
 return bool(x) ? *x < v : true;
}

/**
* \brief Comparison operator.
* \returns <tt>bool(x) ? v < *x : false</tt>.
*/
template <class T>
bool operator>(const T &v, const optional<T> &x) {
 return bool(x) ? v < *x : false;
}

/**
* \brief Comparison operator.
* \returns <tt>!(x < v)</tt>.
*/
template <class T>
bool operator>=(const optional<T> &x, const T &v) {
 return !(x < v);
}

/**
* \brief Comparison operator.
* \returns <tt>!(v < x)</tt>.
*/
template <class T>
bool operator>=(const T &v, const optional<T> &x) {
 return !(v < x);
}

/**
* \brief Comparison operator.
* \returns <tt>!(x > v)</tt>.
*/
template <class T>
bool operator<=(const optional<T> &x, const T &v) {
 return !(x > v);
}

/**
* \brief Comparison operator.
* \returns <tt>!(v > x)</tt>.
*/
template <class T>
bool operator<=(const T &v, const optional<T> &x) {
 return !(v > x);
}

/**
* \ingroup optional
* \brief Swap function.
* \param lhs The first optional object.
* \param rhs The second optional object.
*
* Calls:
* \code{.cpp}
* lhs.swap(rhs);
* \endcode
*/
template <class T>
inline void swap(optional<T> &lhs,
                optional<T> &rhs) noexcept(noexcept(lhs.swap(rhs))) {
 return lhs.swap(rhs);
}

/**
* \ingroup optional
* \brief A helper function to contruct an optional object.
* \returns <tt>optional<typename
* std::decay<T>::type>(std::forward(value))</tt>.
*/
template <class T>
inline constexpr optional<typename std::decay<T>::type> make_optional(
   T &&value) {
 return optional<typename std::decay<T>::type>(std::forward(value));
}
}  // namespace network

#endif  // NETWORK_OPTIONAL_INC

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.