MetainfoValueImpl.h

Go to the documentation of this file.

//===-- serialbox/core/MetainfoValueImpl.h ------------------------------------------*- C++ -*-===//
//
//                                    S E R I A L B O X
//
// This file is distributed under terms of BSD license.
// See LICENSE.txt for more information
//
//===------------------------------------------------------------------------------------------===//
//
//===------------------------------------------------------------------------------------------===//

#ifndef SERIALBOX_CORE_METAINFOVALUEIMPL_H
#define SERIALBOX_CORE_METAINFOVALUEIMPL_H

#include "serialbox/core/Array.h"
#include "serialbox/core/Exception.h"
#include "serialbox/core/Type.h"
#include <boost/any.hpp>
#include <boost/mpl/if.hpp>
#include <type_traits>

namespace serialbox {


class MetainfoValueImpl {
public:
  MetainfoValueImpl() : type_(TypeID::Invalid), any_(){};

  MetainfoValueImpl(const MetainfoValueImpl&) = default;

  MetainfoValueImpl(MetainfoValueImpl&&) = default;

  MetainfoValueImpl& operator=(const MetainfoValueImpl&) = default;

  MetainfoValueImpl& operator=(MetainfoValueImpl&&) = default;

  template <class ValueType, class DecayedValueType = typename std::decay<ValueType>::type,
            class PrimitiveType = typename MakePrimitive<DecayedValueType>::type,
            class = typename std::enable_if<
                !std::is_same<DecayedValueType, MetainfoValueImpl>::value>::type>
  explicit MetainfoValueImpl(ValueType&& value) {
    static_assert(IsSupported<PrimitiveType>::value, "ValueType is not supported");

    type_ = ToTypeID<DecayedValueType>::value;
    any_ = boost::any(DecayedValueType(value));
  }
  explicit MetainfoValueImpl(const char* value) : MetainfoValueImpl(std::string(value)) {}

  template <class T>
  T as() const {
    static_assert(IsSupported<typename MakePrimitive<T>::type>::value,
                  "ValueType is not supported");
    return T(); // Unreachable
  }

  template <class T>
  operator T() const {
    return as<T>();
  }

  void swap(MetainfoValueImpl& other) noexcept {
    any_.swap(other.any_);
    std::swap(type_, other.type_);
  }

  bool operator==(const MetainfoValueImpl& right) const noexcept;

  bool operator!=(const MetainfoValueImpl& right) const noexcept { return (!(*this == right)); }

  TypeID type() const noexcept { return type_; }

  boost::any& any() noexcept { return any_; }
  const boost::any& any() const noexcept { return any_; }

  std::string toString() const;

private:
  template <class T>
  const T& convert() const noexcept {
    return *boost::any_cast<T>(&any_);
  }

private:
  TypeID type_;    
  boost::any any_; 
};

template <>
bool MetainfoValueImpl::as() const;

template <>
int MetainfoValueImpl::as() const;

template <>
std::int64_t MetainfoValueImpl::as() const;

template <>
float MetainfoValueImpl::as() const;

template <>
double MetainfoValueImpl::as() const;

template <>
std::string MetainfoValueImpl::as() const;

template <>
Array<bool> MetainfoValueImpl::as() const;

template <>
Array<int> MetainfoValueImpl::as() const;

template <>
Array<std::int64_t> MetainfoValueImpl::as() const;

template <>
Array<float> MetainfoValueImpl::as() const;

template <>
Array<double> MetainfoValueImpl::as() const;

template <>
Array<std::string> MetainfoValueImpl::as() const;


} // namespace serialbox

#endif