any.hpp

Go to the documentation of this file.

 
/*
  The MIT License (MIT)
 
  Copyright (c) 2020 Matthew Rodusek All rights reserved.
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in
  all copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
#ifndef BPSTD_ANY_HPP
#define BPSTD_ANY_HPP
 
#if defined(_MSC_VER) && (_MSC_VER >= 1200)
# pragma once
#endif // defined(_MSC_VER) && (_MSC_VER >= 1200)
 
#include "detail/config.hpp"
#include "type_traits.hpp"  // enable_if_t, is_*
#include "utility.hpp"      // in_place_type_t, move, forward
 
#include <typeinfo>         // std::bad_cast, std::type_info
#include <initializer_list> // std::initializer_list
#include <new>              // placement-new
#include <cassert>          // assert
 
BPSTD_COMPILER_DIAGNOSTIC_PREAMBLE
 
namespace bpstd {
 
  class any;
 
  //============================================================================
  // class : bad_any_cast
  //============================================================================
 
  class bad_any_cast : public std::bad_cast
  {
    const char* what() const noexcept override;
  };
 
  //============================================================================
  // class : any
  //============================================================================
 
  class any
  {
    //--------------------------------------------------------------------------
    // Constructors / Destructor / Assignment
    //--------------------------------------------------------------------------
  public:
 
    any() noexcept;
 
    any(any&& other) noexcept;
 
    any(const any& other);
 
    template<typename ValueType,
             typename=enable_if_t<!is_same<decay_t<ValueType>,any>::value &&
                                   is_copy_constructible<decay_t<ValueType>>::value>>
    // cppcheck-suppress noExplicitConstructor
    any(ValueType&& value);
 
    template<typename ValueType, typename...Args,
             typename=enable_if_t<is_constructible<decay_t<ValueType>,Args...>::value &&
                                  is_copy_constructible<decay_t<ValueType>>::value>>
    explicit any(in_place_type_t<ValueType>, Args&&...args);
 
    template<typename ValueType, typename U, typename...Args,
             typename=enable_if_t<is_constructible<decay_t<ValueType>,std::initializer_list<U>,Args...>::value &&
                                  is_copy_constructible<decay_t<ValueType>>::value>>
    explicit any(in_place_type_t<ValueType>,
                 std::initializer_list<U> il,
                 Args&&...args);
 
    //--------------------------------------------------------------------------
 
    ~any();
 
    //--------------------------------------------------------------------------
 
    any& operator=(any&& other) noexcept;
 
    any& operator=(const any& other);
 
    template<typename ValueType,
             typename=enable_if_t<!is_same<decay_t<ValueType>,any>::value &&
                                   is_copy_constructible<decay_t<ValueType>>::value>>
    any& operator=(ValueType&& value);
 
    //--------------------------------------------------------------------------
    // Modifiers
    //--------------------------------------------------------------------------
  public:
 
    template<typename ValueType, typename...Args,
              typename=enable_if_t<is_constructible<decay_t<ValueType>,Args...>::value &&
                                   is_copy_constructible<decay_t<ValueType>>::value>>
    decay_t<ValueType>& emplace(Args&&...args);
    template<typename ValueType, typename U, typename...Args,
              typename=enable_if_t<is_constructible<decay_t<ValueType>,std::initializer_list<U>,Args...>::value &&
                                   is_copy_constructible<decay_t<ValueType>>::value>>
    decay_t<ValueType>& emplace(std::initializer_list<U> il, Args&&...args );
 
    void reset() noexcept;
 
    void swap(any& other) noexcept;
 
    //--------------------------------------------------------------------------
    // Observers
    //--------------------------------------------------------------------------
  public:
 
    bool has_value() const noexcept;
 
    const std::type_info& type() const noexcept;
 
    //--------------------------------------------------------------------------
    // Private Static Members / Types
    //--------------------------------------------------------------------------
  private:
 
    // Internal buffer size + alignment
    static constexpr auto buffer_size  = 4u * sizeof(void*);
    static constexpr auto buffer_align = alignof(void*);
 
    // buffer (for internal storage)
    using internal_buffer = typename aligned_storage<buffer_size,buffer_align>::type;
 
    union storage
    {
      internal_buffer internal;
      void*           external;
    };
 
    //--------------------------------------------------------------------------
 
    // trait to determine if internal storage is required
    template<typename T>
    using requires_internal_storage = bool_constant<
      (sizeof(T) <= buffer_size) &&
      ((buffer_align % alignof(T)) == 0) &&
      is_nothrow_move_constructible<T>::value
    >;
 
    //-----------------------------------------------------------------------
 
    template<typename T>
    struct internal_storage_handler;
 
    template<typename T>
    struct external_storage_handler;
 
    template<typename T>
    using storage_handler = conditional_t<
      requires_internal_storage<T>::value,
      internal_storage_handler<T>,
      external_storage_handler<T>
    >;
 
    //-----------------------------------------------------------------------
 
    enum class operation
    {
      destroy, 
      copy,    
      move,    
      value,   
      type,    
    };
 
    //-----------------------------------------------------------------------
 
    using storage_handler_ptr = const void*(*)(operation, const storage*,const storage*);
 
    template<typename T>
    friend T* any_cast(any*) noexcept;
    template<typename T>
    friend const T* any_cast(const any*) noexcept;
 
    //-----------------------------------------------------------------------
    // Private Members
    //-----------------------------------------------------------------------
  private:
 
    storage             m_storage;
    storage_handler_ptr m_storage_handler;
  };
 
  //=========================================================================
  // non-member functions : class : any
  //=========================================================================
 
  //-------------------------------------------------------------------------
  // utilities
  //-------------------------------------------------------------------------
 
  void swap(any& lhs, any& rhs) noexcept;
 
  //-------------------------------------------------------------------------
  // casts
  //-------------------------------------------------------------------------
 
  template<typename T>
  T any_cast(any& operand);
  template<typename T>
  T any_cast(any&& operand);
  template<typename T>
  T any_cast(const any& operand);
 
  template<typename T>
  T* any_cast(any* operand) noexcept;
  template<typename T>
  const T* any_cast(const any* operand) noexcept;
 
} // namespace bpstd
 
//=============================================================================
// definitions : class : bad_any_cast
//=============================================================================
 
inline
const char* bpstd::bad_any_cast::what()
  const noexcept
{
  return "bad_any_cast";
}
 
//=============================================================================
// class : any::internal_storage_handler
//=============================================================================
 
template<typename T>
struct bpstd::any::internal_storage_handler
{
  template<typename...Args>
  static T* construct(storage& s, Args&&...args);
 
  template<typename U, typename...Args>
  static T* construct(storage& s, std::initializer_list<U> il, Args&&...args);
 
  static void destroy(storage& s);
 
  static const void* handle(operation op,
                            const storage* self,
                            const storage* other);
};
 
//=============================================================================
// definition : class : any::internal_storage_handler
//=============================================================================
 
template<typename T>
template<typename...Args>
inline BPSTD_INLINE_VISIBILITY
T* bpstd::any::internal_storage_handler<T>
  ::construct(storage& s, Args&&...args)
{
  return ::new(&s.internal) T(bpstd::forward<Args>(args)...);
}
 
template<typename T>
template<typename U, typename...Args>
inline BPSTD_INLINE_VISIBILITY
T* bpstd::any::internal_storage_handler<T>
  ::construct(storage& s, std::initializer_list<U> il, Args&&...args)
{
  return ::new(&s.internal) T(il, bpstd::forward<Args>(args)...);
}
 
template<typename T>
inline BPSTD_INLINE_VISIBILITY
void bpstd::any::internal_storage_handler<T>
  ::destroy(storage& s)
{
  auto* t = static_cast<T*>(static_cast<void*>(&s.internal));
  t->~T();
}
 
template<typename T>
inline BPSTD_INLINE_VISIBILITY
const void* bpstd::any::internal_storage_handler<T>
  ::handle(operation op,
           const storage* self,
           const storage* other)
{
  switch (op)
  {
    case operation::destroy:
    {
      assert(self != nullptr);
      BPSTD_UNUSED(other);
 
      destroy(const_cast<storage&>(*self));
      break;
    }
 
    case operation::copy:
    {
      assert(self != nullptr);
      assert(other != nullptr);
 
      // Copy construct from the internal storage
      const auto* p = reinterpret_cast<const T*>(&other->internal);
      construct( const_cast<storage&>(*self), *p);
      break;
    }
 
    case operation::move:
    {
      assert(self != nullptr);
      assert(other != nullptr);
 
      // Move construct from the internal storage. '
      const auto* p = reinterpret_cast<const T*>(&other->internal);
      construct(const_cast<storage&>(*self), bpstd::move(*const_cast<T*>(p)));
      break;
    }
 
    case operation::value:
    {
      assert(self != nullptr);
      BPSTD_UNUSED(other);
 
      // NOTE(bitwize): This seemingly arbitrary conversion is for proper
      //   type-safety/correctness. Otherwise, converting an aligned_storage_t*
      //   to void* and then to T* would violate strict-aliasing -- which
      //   would be undefined-behavior. Behavior is only well-defined for
      //   casts from void* to T* if the the void* originated from a T*.
      const auto* p = reinterpret_cast<const T*>(&self->internal);
      return static_cast<const void*>(p);
    }
 
    case operation::type:
    {
      BPSTD_UNUSED(self);
      BPSTD_UNUSED(other);
 
      return static_cast<const void*>(&typeid(T));
    }
  }
  return nullptr;
}
 
//=============================================================================
// class : any::external_storage_handler
//=============================================================================
 
template<typename T>
struct bpstd::any::external_storage_handler
{
  template<typename...Args>
  static T* construct(storage& s, Args&&...args);
 
  template<typename U, typename...Args>
  static T* construct(storage& s, std::initializer_list<U> il, Args&&...args);
 
  static void destroy(storage& s);
 
  static const void* handle(operation op,
                            const storage* self,
                            const storage* other);
};
 
 
//=============================================================================
// definition : class : any::external_storage_handler
//=============================================================================
 
template<typename T>
template<typename...Args>
inline BPSTD_INLINE_VISIBILITY
T* bpstd::any::external_storage_handler<T>
  ::construct(storage& s, Args&&...args)
{
  s.external = new T(bpstd::forward<Args>(args)...);
  return static_cast<T*>(s.external);
}
 
template<typename T>
template<typename U, typename...Args>
inline BPSTD_INLINE_VISIBILITY
T* bpstd::any::external_storage_handler<T>
  ::construct(storage& s, std::initializer_list<U> il, Args&&...args)
{
  s.external = new T(il, bpstd::forward<Args>(args)...);
  return static_cast<T*>(s.external);
}
 
template<typename T>
inline BPSTD_INLINE_VISIBILITY
void bpstd::any::external_storage_handler<T>
  ::destroy(storage& s)
{
  delete static_cast<T*>(s.external);
}
 
template<typename T>
inline BPSTD_INLINE_VISIBILITY
const void* bpstd::any::external_storage_handler<T>
  ::handle( operation op,
            const storage* self,
            const storage* other )
{
  switch (op)
  {
    case operation::destroy:
    {
      assert(self != nullptr);
      BPSTD_UNUSED(other);
 
      destroy(const_cast<storage&>(*self));
      break;
    }
 
    case operation::copy:
    {
      assert(self != nullptr);
      assert(other != nullptr);
 
      // Copy construct from the internal storage
      construct( const_cast<storage&>(*self),
                 *static_cast<const T*>(other->external));
      break;
    }
 
    case operation::move:
    {
      BPSTD_UNUSED(self != nullptr);
      assert(other != nullptr);
 
      const auto p = static_cast<const T*>(other->external);
      // Move construct from the internal storage. '
      construct(const_cast<storage&>(*self), bpstd::move(*const_cast<T*>(p)));
      break;
    }
 
    case operation::value:
    {
      assert(self != nullptr);
      BPSTD_UNUSED(other);
 
      // self->external was already created as a T*; no need to cast like in
      // internal.
      return self->external;
    }
 
    case operation::type:
    {
      BPSTD_UNUSED(self);
      BPSTD_UNUSED(other);
 
      return &typeid(T);
    }
  }
  return nullptr;
}
 
//=============================================================================
// definitions : class : any
//=============================================================================
 
//-----------------------------------------------------------------------------
// Constructors / Destructor / Assignment
//-----------------------------------------------------------------------------
 
inline BPSTD_INLINE_VISIBILITY
bpstd::any::any()
  noexcept
  : m_storage{},
    m_storage_handler{nullptr}
{
 
}
 
inline BPSTD_INLINE_VISIBILITY
bpstd::any::any(any&& other)
  noexcept
  : m_storage{},
    m_storage_handler{other.m_storage_handler}
{
  if (m_storage_handler != nullptr) {
    m_storage_handler(operation::move, &m_storage, &other.m_storage);
  }
}
 
inline BPSTD_INLINE_VISIBILITY
bpstd::any::any(const any& other)
  : m_storage{},
    m_storage_handler{nullptr}
{
 
  if (other.m_storage_handler != nullptr) {
    // Set handler after constructing, in case of exception
    const auto handler = other.m_storage_handler;
 
    handler(operation::copy, &m_storage, &other.m_storage);
    m_storage_handler = handler;
  }
}
 
template<typename ValueType, typename>
inline BPSTD_INLINE_VISIBILITY
bpstd::any::any(ValueType&& value)
  : m_storage{},
    m_storage_handler{nullptr}
{
  // Set handler after constructing, in case of exception
  using handler_type = storage_handler<decay_t<ValueType>>;
 
  handler_type::construct(m_storage, bpstd::forward<ValueType>(value));
  m_storage_handler = &handler_type::handle;
}
 
template<typename ValueType, typename...Args, typename>
inline BPSTD_INLINE_VISIBILITY
bpstd::any::any(in_place_type_t<ValueType>, Args&&...args)
  : m_storage{},
    m_storage_handler{nullptr}
{
  // Set handler after constructing, in case of exception
  using handler_type = storage_handler<decay_t<ValueType>>;
 
  handler_type::construct(m_storage, bpstd::forward<Args>(args)...);
  m_storage_handler = &handler_type::handle;
}
 
template<typename ValueType, typename U, typename...Args, typename>
inline BPSTD_INLINE_VISIBILITY
bpstd::any::any(in_place_type_t<ValueType>,
                       std::initializer_list<U> il,
                       Args&&...args)
  : m_storage{},
    m_storage_handler{nullptr}
{
  // Set handler after constructing, in case of exception
  using handler_type = storage_handler<decay_t<ValueType>>;
 
  handler_type::construct(m_storage, il, bpstd::forward<Args>(args)...);
  m_storage_handler = &handler_type::handle;
}
 
//-----------------------------------------------------------------------------
 
inline BPSTD_INLINE_VISIBILITY
bpstd::any::~any()
{
  reset();
}
 
//-----------------------------------------------------------------------------
 
inline BPSTD_INLINE_VISIBILITY
bpstd::any& bpstd::any::operator=(any&& other)
  noexcept
{
  reset();
 
  if (other.m_storage_handler != nullptr) {
    m_storage_handler = other.m_storage_handler;
    m_storage_handler(operation::move, &m_storage, &other.m_storage);
  }
 
  return (*this);
}
 
inline BPSTD_INLINE_VISIBILITY
bpstd::any& bpstd::any::operator=(const any& other)
{
  reset();
 
  if (other.m_storage_handler != nullptr) {
    // Set handler after constructing, in case of exception
    const auto handler = other.m_storage_handler;
 
    handler(operation::copy, &m_storage, &other.m_storage);
    m_storage_handler = handler;
  }
 
  return (*this);
}
 
template<typename ValueType, typename>
inline BPSTD_INLINE_VISIBILITY
bpstd::any& bpstd::any::operator=(ValueType&& value)
{
  using handler_type = storage_handler<decay_t<ValueType>>;
 
  reset();
 
  handler_type::construct(m_storage, bpstd::forward<ValueType>(value));
  m_storage_handler = &handler_type::handle;
 
  return (*this);
}
 
//-----------------------------------------------------------------------------
// Modifiers
//-----------------------------------------------------------------------------
 
template<typename ValueType, typename...Args, typename>
inline BPSTD_INLINE_VISIBILITY
bpstd::decay_t<ValueType>&
  bpstd::any::emplace(Args&&...args)
{
  using handler_type = storage_handler<decay_t<ValueType>>;
 
  reset();
 
  auto& result = *handler_type::construct(m_storage,
                                          bpstd::forward<Args>(args)...);
  m_storage_handler = &handler_type::handle;
 
  return result;
}
 
template<typename ValueType, typename U, typename...Args, typename>
inline BPSTD_INLINE_VISIBILITY
bpstd::decay_t<ValueType>&
  bpstd::any::emplace(std::initializer_list<U> il,
                      Args&&...args)
{
  using handler_type = storage_handler<decay_t<ValueType>>;
 
  reset();
 
  auto& result = *handler_type::construct(m_storage,
                                          il,
                                          bpstd::forward<Args>(args)...);
  m_storage_handler = &handler_type::handle;
 
  return result;
}
 
inline BPSTD_INLINE_VISIBILITY
void bpstd::any::reset()
  noexcept
{
  if (m_storage_handler != nullptr) {
    m_storage_handler(operation::destroy, &m_storage, nullptr);
    m_storage_handler = nullptr;
  }
}
 
inline BPSTD_INLINE_VISIBILITY
void bpstd::any::swap(any& other)
  noexcept
{
  using std::swap;
 
  if (m_storage_handler != nullptr && other.m_storage_handler != nullptr)
  {
    auto tmp = any{};
 
    // tmp := self
    tmp.m_storage_handler = m_storage_handler;
    m_storage_handler(operation::move, &tmp.m_storage, &m_storage);
    m_storage_handler(operation::destroy, &m_storage, nullptr);
 
    // self := other
    m_storage_handler = other.m_storage_handler;
    m_storage_handler(operation::move, &m_storage, &other.m_storage);
    m_storage_handler(operation::destroy, &other.m_storage, nullptr);
 
    // other := tmp
    other.m_storage_handler = tmp.m_storage_handler;
    other.m_storage_handler(operation::move, &other.m_storage, &tmp.m_storage);
  }
  else if (other.m_storage_handler != nullptr)
  {
    swap(m_storage_handler, other.m_storage_handler);
 
    // self := other
    m_storage_handler(operation::move, &m_storage, &other.m_storage);
    m_storage_handler(operation::destroy, &other.m_storage, nullptr);
  }
  else if (m_storage_handler != nullptr)
  {
    swap(m_storage_handler, other.m_storage_handler);
 
    // other := self
    other.m_storage_handler(operation::move, &other.m_storage, &m_storage);
    other.m_storage_handler(operation::destroy, &m_storage, nullptr);
  }
}
 
//-----------------------------------------------------------------------------
// Observers
//-----------------------------------------------------------------------------
 
inline BPSTD_INLINE_VISIBILITY
bool bpstd::any::has_value()
  const noexcept
{
  return m_storage_handler != nullptr;
}
 
inline BPSTD_INLINE_VISIBILITY
const std::type_info& bpstd::any::type()
  const noexcept
{
  if (has_value()) {
    auto* p = m_storage_handler(operation::type, nullptr, nullptr);
    return (*static_cast<const std::type_info*>(p));
  }
  return typeid(void);
}
 
//=============================================================================
// definition : non-member functions : class : any
//=============================================================================
 
//-----------------------------------------------------------------------------
// utilities
//-----------------------------------------------------------------------------
 
inline BPSTD_INLINE_VISIBILITY
void bpstd::swap(any& lhs, any& rhs)
  noexcept
{
  lhs.swap(rhs);
}
 
//-----------------------------------------------------------------------------
// casts
//-----------------------------------------------------------------------------
 
template<typename T>
inline BPSTD_INLINE_VISIBILITY
T bpstd::any_cast(any& operand)
{
  using underlying_type = remove_cvref_t<T>;
 
  static_assert(
    is_constructible<T, underlying_type&>::value,
    "A program is ill-formed if T is not constructible from U&"
  );
 
  auto* p = any_cast<underlying_type>(&operand);
  if (p == nullptr) {
    throw bad_any_cast{};
  }
  return static_cast<T>(*p);
}
 
template<typename T>
inline BPSTD_INLINE_VISIBILITY
T bpstd::any_cast(any&& operand)
{
  using underlying_type = remove_cvref_t<T>;
 
  static_assert(
    is_constructible<T, underlying_type>::value,
    "A program is ill-formed if T is not constructible from U"
  );
 
  auto* p = any_cast<underlying_type>(&operand);
  if (p == nullptr) {
    throw bad_any_cast{};
  }
  return static_cast<T>(bpstd::move(*p));
}
 
template<typename T>
inline BPSTD_INLINE_VISIBILITY
T bpstd::any_cast(const any& operand)
{
  using underlying_type = remove_cvref_t<T>;
 
  static_assert(
    is_constructible<T, const underlying_type&>::value,
    "A program is ill-formed if T is not constructible from const U&"
  );
 
  const auto* p = any_cast<underlying_type>(&operand);
  if (p == nullptr) {
    throw bad_any_cast{};
  }
  return static_cast<T>(*p);
}
 
template<typename T>
inline BPSTD_INLINE_VISIBILITY
T* bpstd::any_cast(any* operand)
  noexcept
{
  if (!operand) {
    return nullptr;
  }
  if (operand->type() != typeid(T)) {
    return nullptr;
  }
 
  auto p = operand->m_storage_handler(any::operation::value,
                                      &operand->m_storage,
                                      nullptr);
  return const_cast<T*>(static_cast<const T*>(p));
}
 
template<typename T>
inline BPSTD_INLINE_VISIBILITY
const T* bpstd::any_cast(const any* operand)
  noexcept
{
  if (!operand) {
    return nullptr;
  }
  if (operand->type() != typeid(T)) {
    return nullptr;
  }
 
  auto* p = operand->m_storage_handler(any::operation::value,
                                       &operand->m_storage,
                                       nullptr);
  return static_cast<const T*>(p);
}
 
BPSTD_COMPILER_DIAGNOSTIC_POSTAMBLE
 
#endif /* BPSTD_ANY_HPP */