Any.hpp

#pragma once
 
#include "DM/config.hpp"
#include "DM/AutoLink.hpp" //enable autolink
#include "DM/Exception.hpp"
 
#include <typeindex>
#include <type_traits>
 
DM_NAMESPACE_BEGIN
 
  /**
  \class  Any
 
  \author jo
  \date   27.01.2012
 
  Any can store any object without sacrificing type safety. Class is strongly based on boost::any except
  that the type() member function doesn't return a const std::type_index & (but a copy std::type_index)
  */
 
  class DM_API Any
  {
  public: // structors
    Any() noexcept: content(0) {
    }
 
    template<typename ValueType>
    Any(const ValueType & value) : content(new holder<
        typename std::remove_cv<typename std::decay<const ValueType>::type>::type
        >(value)) {
    }
 
    Any(const Any & other) : content(other.content ? other.content->clone() : 0) {
    }
 
    // Move constructor
    Any(Any&& other) noexcept : content(other.content) {
        other.content = 0;
    }
 
    // Perfect forwarding of ValueType
    template<typename ValueType>
    Any(ValueType&& value  
        , typename std::enable_if< !std::is_same<Any&, ValueType>::value >::type* = 0 // disable if value has type `any&`
        , typename std::enable_if< !std::is_const<ValueType>::value >::type* = 0) // disable if value has type `const ValueType&&`
      : content(new holder< typename std::decay<ValueType>::type >(static_cast<ValueType&&>(value)))
    {
    }
 
    ~Any() noexcept {
        delete content;
    }
 
  public: // modifiers
    Any & swap(Any & rhs) noexcept {
        std::swap(content, rhs.content);
        return *this;
    }
 
    Any & operator=(const Any& rhs) {
        Any(rhs).swap(*this);
        return *this;
    }
 
    // move assignement
    Any & operator=(Any&& rhs) noexcept
    {
        rhs.swap(*this);
        Any().swap(rhs);
        return *this;
    }
 
    // Perfect forwarding of ValueType
    template <class ValueType>
    Any & operator=(ValueType&& rhs)
    {
        Any(static_cast<ValueType&&>(rhs)).swap(*this);
        return *this;
    }
 
  public: // queries
    bool empty() const noexcept {
        return !content;
    }
    void clear() noexcept {
        Any().swap(*this);
    }
    std::type_index type() const noexcept {
        return content ? content->type() : std::type_index(typeid(void));
    }
 
  private: // types
 
    class placeholder
    {
    public: // structors
      virtual ~placeholder() { }
 
    public: // queries
      virtual std::type_index type() const noexcept = 0;
      virtual placeholder * clone() const = 0;
    };
 
    template<typename ValueType>
    class holder : public placeholder
    {
    public: // structors
      holder(const ValueType & value) : held(value)  { }
      holder(ValueType&& value) : held(static_cast< ValueType&& >(value)) { }
 
    public: // queries
      virtual std::type_index type() const noexcept {
          return std::type_index(typeid(ValueType));
      }
      virtual placeholder * clone() const {
          return new holder(held);
      }
 
    public: // representation
        ValueType held;
 
    private: // intentionally left unimplemented
        holder & operator=(const holder &);
    };
 
  private: // representation
 
    template<typename ValueType>
    friend ValueType * any_cast(Any *) noexcept;
    template<typename ValueType>
    friend ValueType * unsafe_any_cast(Any *) noexcept;
 
    placeholder * content;
  };
 
  inline void swap(Any & lhs, Any & rhs) noexcept { lhs.swap(rhs);  }
 
  class DM_API BadAnyCast : public NG_exception
  {
  public:
      virtual const char * what() const noexcept{
          return "boost::bad_any_cast: failed conversion using boost::any_cast";
      }
  };
 
  template<typename ValueType>
  ValueType * any_cast(Any * operand) noexcept
  {
    return operand && operand->type() == std::type_index(typeid(ValueType))
        ? std::addressof(
            static_cast<Any::holder<typename std::remove_cv<ValueType>::type> *>(operand->content)->held
          )
        : 0;
  }
 
  template<typename ValueType>
  inline const ValueType * any_cast(const Any * operand) noexcept
  {
    return any_cast<ValueType>(const_cast<Any *>(operand));
  }
 
  template<typename ValueType>
  ValueType any_cast(Any & operand)
  {
    typedef typename std::remove_reference<ValueType>::type nonref;
 
    nonref * result = any_cast<nonref>(std::addressof(operand));
    if(!result)
        throw BadAnyCast();
 
    // Attempt to avoid construction of a temporary object in cases when 
    // `ValueType` is not a reference. Example:
    // `static_cast<std::string>(*result);` 
    // which is equal to `std::string(*result);`
    typedef typename std::conditional <
      std::is_reference<ValueType>::value ,
        ValueType,
        typename std::add_lvalue_reference<ValueType>::type
    >::type ref_type;
 
#ifdef _MSC_VER
#   pragma warning(push)
#   pragma warning(disable: 4172) // "returning address of local variable or temporary" but *result is not local!
#endif
    return static_cast<ref_type>(*result);
#ifdef _MSC_VER
#   pragma warning(pop)
#endif
  }
 
  template<typename ValueType>
  inline ValueType any_cast(const Any & operand)
  {
    typedef typename std::remove_reference<ValueType>::type nonref;
    return any_cast<const nonref &>(const_cast<Any &>(operand));
  }
 
 
DM_NAMESPACE_END