ObjectWrapperT.hpp

Go to the documentation of this file.

/*
 * ObjectWrapperT.hpp
 *
 *  Created on: 04 Dec 2017
 *      Author: Nicola Mori
 */

#ifndef OBJECTWRAPPERT_HPP_
#define OBJECTWRAPPERT_HPP_

#include "core/InheritsFrom.h"
#include "utils/SmartLog.h"

namespace EA {

template <typename DataType>
ObjectWrapperTImpl<DataType>::ObjectWrapperTImpl(observer_ptr<DataType> dataObjPtr)
    : _dataObjPtr(dataObjPtr), _dataObjSharedPtr(nullptr) {}

template <typename DataType>
ObjectWrapperTImpl<DataType>::ObjectWrapperTImpl(std::shared_ptr<DataType> dataObjPtr)
    : _dataObjPtr(dataObjPtr.get()), _dataObjSharedPtr(dataObjPtr) {}

template <typename DataType>
ObjectWrapperTImpl<DataType>::ObjectWrapperTImpl(std::unique_ptr<DataType> dataObjPtr)
    : _dataObjPtr(dataObjPtr.get()), _dataObjSharedPtr(std::shared_ptr<DataType>(std::move(dataObjPtr))) {}

template <typename DataType>
ObjectWrapperTImpl<DataType>::ObjectWrapperTImpl(const ObjectWrapperTImpl<DataType> &original)
    : _dataObjPtr(original._dataObjPtr), _dataObjSharedPtr(original._dataObjSharedPtr) {}

template <typename DataType> observer_ptr<DataType> ObjectWrapperTImpl<DataType>::GetObj() { return _dataObjPtr; }

template <typename DataType> bool ObjectWrapperTImpl<DataType>::IsPolymorphic() {
  return std::is_polymorphic<DataType>::value;
}

template <typename DataType> bool ObjectWrapperTImpl<DataType>::IsConst() { return std::is_const<DataType>::value; }

template <typename DataType>
std::unique_ptr<ObjectWrapperBase>
ObjectWrapperT<DataType, typename std::enable_if<smart_is_copy_constructible<DataType>::value>::type>::CloneObject() {
  if (ObjectWrapperTImpl<DataType>::_dataObjPtr) {
    return std::make_unique<ObjectWrapperT<DataType, void>>(
        std::shared_ptr<DataType>(new DataType(*ObjectWrapperTImpl<DataType>::_dataObjPtr)));
  } else {
    return std::make_unique<ObjectWrapperT<DataType, void>>(
        std::shared_ptr<DataType>(new DataType(*ObjectWrapperTImpl<DataType>::_dataObjSharedPtr)));
  }
}
template <typename DataType>
bool ObjectWrapperTImpl<DataType>::WrapObject(void *address, const std::type_info &type, bool own, bool isPolymorphic,
                                              bool isConst) {
  static const std::string routineName(
      std::string("ObjectWrapperTImpl<").append(Demangler::ClassName<DataType>()).append(">::WrapObject"));
  if (InheritsFrom(type, typeid(DataType))) {
    if (isPolymorphic != std::is_polymorphic<DataType>::value) {
      COUT(ERROR) << "The value for the \"isPolymorphic\" argument does not match the one for class \""
                  << Demangler::ClassName<DataType>() << "\"" << ENDL;
      return false;
    }
    if (isConst && !std::is_const<DataType>::value) {
      COUT(ERROR) << "Can't wrap a const \"" << Demangler::ClassName(type)
                  << "\" object with a wrapper for non-const \"" << Demangler::ClassName<DataType>() << "\" objects "
                  << ENDL;
      return false;
    }
    if (own)
      _dataObjSharedPtr = std::shared_ptr<DataType>((DataType *)address);
    else
      _dataObjPtr = (DataType *)(address);
    return true;
  } else {
    COUT(ERROR) << "Can't wrap an object of type \"" << Demangler::ClassName(type) << "\" in a wrapper for type \""
                << Demangler::ClassName<DataType>() << "\"" << ENDL;
    return false;
  }
}

} // namespace EA

#endif /* OBJECTWRAPPERT_HPP_ */