error.h

Go to the documentation of this file.

/******************************************************************************
 * Copyright 2020 ETC Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *******************************************************************************
 * This file is a part of EtcPal. For more information, go to:
 * https://github.com/ETCLabs/EtcPal
 ******************************************************************************/
 
 
#ifndef ETCPAL_CPP_ERROR_H_
#define ETCPAL_CPP_ERROR_H_
 
#include <cassert>
#include <stdexcept>
#include <string>
#include "etcpal/error.h"
#include "etcpal/cpp/common.h"
 
namespace etcpal
{
 
// etcpal::Error
 
class Error
{
public:
  Error() = delete;
  // Note: this constructor is not explicit by design, to allow implicit conversions e.g.
  //   etcpal::Error FunctionReturningError()
  //   {
  //     return kEtcPalErrOk;
  //   }
  constexpr Error(etcpal_error_t code) noexcept;
  Error& operator=(etcpal_error_t code) noexcept;
 
  constexpr bool           IsOk() const noexcept;
  constexpr etcpal_error_t code() const noexcept;
  std::string              ToString() const;
  const char*              ToCString() const noexcept;
 
  constexpr explicit operator bool() const noexcept;
 
  static constexpr Error Ok() noexcept;
 
private:
  etcpal_error_t code_{kEtcPalErrOk};
};
 
constexpr Error::Error(etcpal_error_t code) noexcept : code_(code)
{
}
 
inline Error& Error::operator=(etcpal_error_t code) noexcept
{
  code_ = code;
  return *this;
}
 
constexpr bool Error::IsOk() const noexcept
{
  return code_ == kEtcPalErrOk;
}
 
constexpr etcpal_error_t Error::code() const noexcept
{
  return code_;
}
 
inline std::string Error::ToString() const
{
  return etcpal_strerror(code_);
}
 
inline const char* Error::ToCString() const noexcept
{
  return etcpal_strerror(code_);
}
 
constexpr Error::operator bool() const noexcept
{
  return IsOk();
}
 
constexpr Error Error::Ok() noexcept
{
  return Error(kEtcPalErrOk);
}
 
 
 
constexpr bool operator==(etcpal_error_t code, const Error& error)
{
  return code == error.code();
}
 
constexpr bool operator!=(etcpal_error_t code, const Error& error)
{
  return !(code == error);
}
 
constexpr bool operator==(const Error& error, etcpal_error_t code)
{
  return error.code() == code;
}
 
constexpr bool operator!=(const Error& error, etcpal_error_t code)
{
  return !(error == code);
}
 
constexpr bool operator==(const Error& a, const Error& b)
{
  return a.code() == b.code();
}
 
constexpr bool operator!=(const Error& a, const Error& b)
{
  return !(a == b);
}
 
 
// etcpal::BadExpectedAccess
 
class BadExpectedAccess : public std::logic_error
{
public:
  explicit BadExpectedAccess(Error res);
  Error error() const noexcept;
 
private:
  Error err_;
};
 
inline BadExpectedAccess::BadExpectedAccess(Error err)
    : std::logic_error("Bad access to etcpal::Expected::value(); the Expected instance contained error '" +
                       err.ToString() + "'.")
    , err_(err)
{
}
 
inline Error BadExpectedAccess::error() const noexcept
{
  return err_;
}
 
 
// etcpal::Expected internals
 
template <typename T>
class Expected;
 
namespace detail
{
// This method of implementing Expected's storage, with copy and move functionality, was borrowed
// with love from a generic header-only expected implementation by martinmoene:
// https://github.com/martinmoene/expected-lite
 
template <typename T>
class ExpectedStorageImpl
{
public:
  using ValueType = T;
 
  // Do not construct or destruct members on construction or destruction
  ExpectedStorageImpl() {}
  ~ExpectedStorageImpl() {}
  explicit ExpectedStorageImpl(bool has_value) : has_value_(has_value) {}
 
  void ConstructValue(const ValueType& v) { new (&value_) ValueType(v); }
  void ConstructValue(ValueType&& v) { new (&value_) ValueType(std::move(v)); }
  void SetError(etcpal_error_t e) { error_ = e; }
 
  void DestructValue() { value_.~ValueType(); }
 
  constexpr const ValueType&  value() const& { return value_; }
  ValueType&                  value() & { return value_; }
  constexpr const ValueType&& value() const&& { return std::move(value_); }
  ETCPAL_CONSTEXPR_14 ValueType&& value() && { return std::move(value_); }
  const ValueType*                value_ptr() const { return &value_; }
  ValueType*                      value_ptr() { return &value_; }
 
  etcpal_error_t error() const { return error_; }
 
  bool has_value() const { return has_value_; }
  void SetHasValue(bool v) { has_value_ = v; }
 
private:
  bool has_value_{false};
  union
  {
    ValueType      value_;
    etcpal_error_t error_;
  };
};
 
// The ExpectedStorage class provides a way to conditionally delete the copy and/or move
// constructors of etcpal::Expected based on the copyability and moveability of the T that we are
// being specialized with.
//
// We provide a generic template where the copy and move constructors are both deleted, then 3
// specializations, for (copyable and movable), (copyable and not moveable), and (moveable and not
// copyable) respectively.
template <typename T, bool IsCopyConstructible, bool IsMoveConstructible>
class ExpectedStorage : public ExpectedStorageImpl<T>
{
public:
  ExpectedStorage() = default;
  ~ExpectedStorage() = default;
 
  explicit ExpectedStorage(bool has_value) : ExpectedStorageImpl<T>(has_value) {}
 
  ExpectedStorage(const ExpectedStorage& other) = delete;
  ExpectedStorage(ExpectedStorage&& other) = delete;
};
 
template <typename T>
class ExpectedStorage<T, true, true> : public ExpectedStorageImpl<T>
{
public:
  ExpectedStorage() = default;
  ~ExpectedStorage() = default;
 
  explicit ExpectedStorage(bool has_value) : ExpectedStorageImpl<T>(has_value) {}
 
  ExpectedStorage(const ExpectedStorage& other) : ExpectedStorageImpl<T>(other.has_value())
  {
    if (this->has_value())
      this->ConstructValue(other.value());
    else
      this->SetError(other.error());
  }
 
  ExpectedStorage(ExpectedStorage&& other) : ExpectedStorageImpl<T>(other.has_value())
  {
    if (this->has_value())
      this->ConstructValue(std::move(other.value()));
    else
      this->SetError(other.error());
  }
};
 
template <typename T>
class ExpectedStorage<T, true, false> : public ExpectedStorageImpl<T>
{
public:
  ExpectedStorage() = default;
  ~ExpectedStorage() = default;
 
  explicit ExpectedStorage(bool has_value) : ExpectedStorageImpl<T>(has_value) {}
 
  ExpectedStorage(const ExpectedStorage& other) : ExpectedStorageImpl<T>(other.has_value())
  {
    if (this->has_value())
      this->ConstructValue(other.value());
    else
      this->SetError(other.error());
  }
 
  ExpectedStorage(ExpectedStorage&& other) = delete;
};
 
template <typename T>
class ExpectedStorage<T, false, true> : public ExpectedStorageImpl<T>
{
public:
  ExpectedStorage() = default;
  ~ExpectedStorage() = default;
 
  explicit ExpectedStorage(bool has_value) : ExpectedStorageImpl<T>(has_value) {}
 
  ExpectedStorage(ExpectedStorage const& other) = delete;
 
  ExpectedStorage(ExpectedStorage&& other) : ExpectedStorageImpl<T>(other.has_value())
  {
    if (this->has_value())
      this->ConstructValue(std::move(other.value()));
    else
      this->SetError(other.error());
  }
};
};  // namespace detail
 
 
// etcpal::Expected
 
template <typename T>
class Expected
{
private:
  template <typename>
  friend class Expected;
 
public:
  static_assert(!std::is_reference<T>::value, "T must not be a reference");
  static_assert(!std::is_same<T, etcpal_error_t>::value, "T must not be etcpal_error_t");
  static_assert(!std::is_same<T, Error>::value, "T must not be etcpal::Error");
  static_assert(!std::is_void<T>::value, "T must not be void");
 
  using ValueType = T;
 
  // Typical ETC library style is to place all function definitions outside the class definition;
  // however, this gets nasty with these templates so the constructors are an exception here.
 
  // clang-format off
 
  template <bool B = std::is_default_constructible<T>::value, typename std::enable_if<B, int>::type = 0>
  ETCPAL_CONSTEXPR_14 Expected() : contained_(true)
  {
    contained_.ConstructValue(ValueType());
  }
 
  ETCPAL_CONSTEXPR_14 Expected(const Expected& other) = default;
 
  ETCPAL_CONSTEXPR_14 Expected(Expected&& other) = default;
 
  template<typename U>
  ETCPAL_CONSTEXPR_14 explicit Expected(const Expected<U>& other,
                                        ETCPAL_ENABLE_IF_ARG(
                                            std::is_constructible<T, const U&>::value &&
                                           !std::is_constructible<T, Expected<U>&>::value &&
                                           !std::is_constructible<T, Expected<U>       &&   >::value &&
                                           !std::is_constructible<T, Expected<U> const &    >::value &&
                                           !std::is_constructible<T, Expected<U> const &&   >::value &&
                                           !std::is_convertible<     Expected<U>       & , T>::value &&
                                           !std::is_convertible<     Expected<U>       &&, T>::value &&
                                           !std::is_convertible<     Expected<U> const & , T>::value &&
                                           !std::is_convertible<     Expected<U> const &&, T>::value &&
                                           !std::is_convertible<const U&, T>::value
                                       ))
      : contained_(other.has_value())
  {
    if (has_value())
      contained_.ConstructValue(T{other.contained_.value()});
    else
      contained_.SetError(other.contained_.error());
  }
 
  template<typename U>
  ETCPAL_CONSTEXPR_14 Expected(const Expected<U>& other,
                               ETCPAL_ENABLE_IF_ARG(
                                   std::is_constructible<T, const U&>::value &&
                                  !std::is_constructible<T, Expected<U>       &    >::value &&
                                  !std::is_constructible<T, Expected<U>       &&   >::value &&
                                  !std::is_constructible<T, Expected<U> const &    >::value &&
                                  !std::is_constructible<T, Expected<U> const &&   >::value &&
                                  !std::is_convertible<     Expected<U>       & , T>::value &&
                                  !std::is_convertible<     Expected<U>       &&, T>::value &&
                                  !std::is_convertible<     Expected<U> const  &, T>::value &&
                                  !std::is_convertible<     Expected<U> const &&, T>::value &&
                                  std::is_convertible<const U&, T>::value
                              ))
      : contained_(other.has_value())
  {
    if (has_value())
      contained_.ConstructValue(other.contained_.value());
    else
      contained_.SetError(other.contained_.error());
  }
 
  template<typename U>
  ETCPAL_CONSTEXPR_14 explicit Expected(Expected<U>&& other,
                                        ETCPAL_ENABLE_IF_ARG(
                                            std::is_constructible<T, U>::value &&
                                           !std::is_constructible<T, Expected<U>       &    >::value &&
                                           !std::is_constructible<T, Expected<U>       &&   >::value &&
                                           !std::is_constructible<T, Expected<U> const &    >::value &&
                                           !std::is_constructible<T, Expected<U> const &&   >::value &&
                                           !std::is_convertible<     Expected<U>       & , T>::value &&
                                           !std::is_convertible<     Expected<U>       &&, T>::value &&
                                           !std::is_convertible<     Expected<U> const & , T>::value &&
                                           !std::is_convertible<     Expected<U> const &&, T>::value &&
                                           !std::is_convertible<U, T>::value
                                       ))
      : contained_(other.has_value())
  {
    if (has_value())
      contained_.ConstructValue(T{std::move(other.contained_.value())});
    else
      contained_.SetError(other.contained_.error());
  }
 
  template<typename U>
  ETCPAL_CONSTEXPR_14 Expected(Expected<U>&& other,
                               ETCPAL_ENABLE_IF_ARG(
                                   std::is_constructible<T, U>::value &&
                                  !std::is_constructible<T, Expected<U>      &     >::value &&
                                  !std::is_constructible<T, Expected<U>      &&    >::value &&
                                  !std::is_constructible<T, Expected<U> const &    >::value &&
                                  !std::is_constructible<T, Expected<U> const &&   >::value &&
                                  !std::is_convertible<     Expected<U>       & , T>::value &&
                                  !std::is_convertible<     Expected<U>       &&, T>::value &&
                                  !std::is_convertible<     Expected<U> const & , T>::value &&
                                  !std::is_convertible<     Expected<U> const &&, T>::value &&
                                   std::is_convertible<U, T>::value
                              ))
      : contained_(other.has_value())
  {
    if (has_value())
      contained_.ConstructValue(std::move(other.contained_.value()));
    else
      contained_.SetError(other.contained_.error());
  }
 
  template <typename U = T>
  ETCPAL_CONSTEXPR_14 explicit Expected(U&& value,
                                        ETCPAL_ENABLE_IF_ARG( std::is_constructible<T, U&&>::value &&
                                                             !std::is_convertible<U&&, T>::value
                                                            )) noexcept(std::is_nothrow_move_constructible<U>::value)
      : contained_(true)
  {
    contained_.ConstructValue(T{std::forward<U>(value)});
  }
 
  template <typename U = T>
  ETCPAL_CONSTEXPR_14 Expected(U&& value, ETCPAL_ENABLE_IF_ARG(std::is_constructible<T, U&&>::value &&
                                                               std::is_convertible<U&&, T>::value
                                                              )) noexcept(std::is_nothrow_move_constructible<U>::value)
      : contained_(true)
  {
    contained_.ConstructValue(std::forward<U>(value));
  }
 
  // clang-format on
 
  // Always implicit by design
  ETCPAL_CONSTEXPR_14 Expected(etcpal_error_t error);
  ~Expected();
 
  constexpr const T*  operator->() const;
  T*                  operator->();
  constexpr const T&  operator*() const&;
  T&                  operator*() &;
  constexpr const T&& operator*() const&&;
  ETCPAL_CONSTEXPR_14 T&&   operator*() &&;
  constexpr explicit        operator bool() const noexcept;
  constexpr bool            has_value() const noexcept;
  ETCPAL_CONSTEXPR_14 const T& value() const&;
  T&                           value() &;
  ETCPAL_CONSTEXPR_14 const T&& value() const&&;
  ETCPAL_CONSTEXPR_14 T&&  value() &&;
  constexpr etcpal_error_t error_code() const noexcept;
  constexpr Error          error() const noexcept;
 
  // clang-format off
 
  template <typename U,
            ETCPAL_ENABLE_IF_TEMPLATE(std::is_copy_constructible<T>::value && std::is_convertible<U&&, T>::value)>
  constexpr T value_or(U&& def_val) const&
  {
    return has_value() ? contained_.value() : static_cast<T>(std::forward<U>(def_val));
  }
 
  template <typename U,
            ETCPAL_ENABLE_IF_TEMPLATE(std::is_move_constructible<T>::value && std::is_convertible<U&&, T>::value)>
  T value_or(U&& def_val) &&
  {
    return has_value() ? contained_.value() : static_cast<T>(std::forward<U>(def_val));
  }
 
  // clang-format on
 
private:
  detail::ExpectedStorage<T, std::is_copy_constructible<T>::value, std::is_move_constructible<T>::value> contained_;
};  // namespace etcpal
 
template <typename T>
ETCPAL_CONSTEXPR_14 Expected<T>::Expected(etcpal_error_t error) : contained_(false)
{
  contained_.SetError(error);
}
 
template <typename T>
Expected<T>::~Expected()
{
  if (has_value())
    contained_.DestructValue();
}
 
template <typename T>
constexpr const T* Expected<T>::operator->() const
{
  // Comma syntax is to satisfy C++11 requirements for constexpr
  return assert(has_value()), contained_.value_ptr();
}
 
template <typename T>
T* Expected<T>::operator->()
{
  // Comma syntax is to satisfy C++11 requirements for constexpr
  return assert(has_value()), contained_.value_ptr();
}
 
template <typename T>
constexpr const T& Expected<T>::operator*() const&
{
  // Comma syntax is to satisfy C++11 requirements for constexpr
  return assert(has_value()), contained_.value();
}
 
template <typename T>
T& Expected<T>::operator*() &
{
  // Comma syntax is to satisfy C++11 requirements for constexpr
  return assert(has_value()), contained_.value();
}
 
template <typename T>
constexpr const T&& Expected<T>::operator*() const&&
{
  // Comma syntax is to satisfy C++11 requirements for constexpr
  return assert(has_value()), std::move(contained_.value());
}
 
template <typename T>
ETCPAL_CONSTEXPR_14 T&& Expected<T>::operator*() &&
{
  // Comma syntax is to satisfy C++11 requirements for constexpr
  return assert(has_value()), std::move(contained_.value());
}
 
template <typename T>
constexpr Expected<T>::operator bool() const noexcept
{
  return has_value();
}
 
template <typename T>
constexpr bool Expected<T>::has_value() const noexcept
{
  return contained_.has_value();
}
 
template <typename T>
ETCPAL_CONSTEXPR_14 const T& Expected<T>::value() const&
{
  if (!has_value())
    ETCPAL_THROW(BadExpectedAccess(contained_.error()));
  return contained_.value();
}
 
template <typename T>
T& Expected<T>::value() &
{
  if (!has_value())
    ETCPAL_THROW(BadExpectedAccess(contained_.error()));
  return contained_.value();
}
 
template <typename T>
ETCPAL_CONSTEXPR_14 const T&& Expected<T>::value() const&&
{
  if (!has_value())
    ETCPAL_THROW(BadExpectedAccess(contained_.error()));
  return std::move(contained_.value());
}
 
template <typename T>
ETCPAL_CONSTEXPR_14 T&& Expected<T>::value() &&
{
  if (!has_value())
    ETCPAL_THROW(BadExpectedAccess(contained_.error()));
  return std::move(contained_.value());
}
 
template <typename T>
constexpr etcpal_error_t Expected<T>::error_code() const noexcept
{
  // Comma syntax is to satisfy C++11 requirements for constexpr
  return assert(!has_value()), contained_.error();
}
 
template <typename T>
constexpr Error Expected<T>::error() const noexcept
{
  // Comma syntax is to satisfy C++11 requirements for constexpr
  return assert(!has_value()), contained_.error();
}
 
 
 
template <typename T1, typename T2>
constexpr bool operator==(const Expected<T1>& x, const Expected<T2>& y)
{
  return bool(x) != bool(y) ? false : bool(x) == false ? x.error_code() == y.error_code() : *x == *y;
}
 
template <typename T1, typename T2>
constexpr bool operator!=(const Expected<T1>& x, const Expected<T2>& y)
{
  return !(x == y);
}
 
template <typename T1, typename T2>
constexpr bool operator==(const Expected<T1>& x, const T2& v)
{
  return bool(x) ? *x == v : false;
}
 
template <typename T1, typename T2>
constexpr bool operator==(const T2& v, const Expected<T1>& x)
{
  return bool(x) ? v == *x : false;
}
 
template <typename T1, typename T2>
constexpr bool operator!=(const Expected<T1>& x, const T2& v)
{
  return bool(x) ? *x != v : true;
}
 
template <typename T1, typename T2>
constexpr bool operator!=(const T2& v, const Expected<T1>& x)
{
  return bool(x) ? v != *x : true;
}
 
template <typename T>
constexpr bool operator==(const Expected<T>& x, etcpal_error_t e)
{
  return (!x) ? x.error_code() == e : false;
}
 
template <typename T>
constexpr bool operator==(etcpal_error_t e, const Expected<T>& x)
{
  return (x == e);
}
 
template <typename T>
constexpr bool operator!=(const Expected<T>& x, etcpal_error_t e)
{
  return !(x == e);
}
 
template <typename T>
constexpr bool operator!=(etcpal_error_t e, const Expected<T>& x)
{
  return !(x == e);
}
 
 
};  // namespace etcpal
 
#endif  // ETCPAL_CPP_ERROR_H_