ObjectWrapperT.h

Go to the documentation of this file.

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

#ifndef OBJECTWRAPPERT_H_
#define OBJECTWRAPPERT_H_

#include "core/ObjectWrapperBase.h"
#include "core/ObserverPtr.h"
#include "core/Traits.h"
#include "utils/Demangler.h"

namespace EA {

template <typename DataType> class ObjectWrapperTImpl : public ObjectWrapperBase {
public:
  ObjectWrapperTImpl(observer_ptr<DataType> dataObjPtr);

  ObjectWrapperTImpl(std::shared_ptr<DataType> dataObjPtr);

  ObjectWrapperTImpl(std::unique_ptr<DataType> dataObjPtr);

  ObjectWrapperTImpl(const ObjectWrapperTImpl<DataType> &);

  observer_ptr<DataType> GetObj();

  bool IsPolymorphic();

  bool IsConst();

  const std::type_info &GetObjType() { return typeid(DataType); }

  void WrapNothing() {
    _dataObjPtr = nullptr;
    _dataObjSharedPtr = nullptr;
  }

  bool WrapsSomething() { return _dataObjPtr || _dataObjSharedPtr; }

  void *GetObjAddress() { return (void *)(_dataObjPtr ? _dataObjPtr.get() : _dataObjSharedPtr.get()); }

  bool WrapObject(void *address, const std::type_info &type, bool own, bool isPolymorphic, bool isConst);

protected:
  observer_ptr<DataType> _dataObjPtr;
  std::shared_ptr<DataType> _dataObjSharedPtr;
};

template <> class ObjectWrapperTImpl<void> : public ObjectWrapperBase {
public:
  ObjectWrapperTImpl(void *dataObjPtr, const std::type_info &type, bool isPolymorphic, bool isConst)
      : _dataObjPtr{dataObjPtr}, _type{type}, _isPolymorphic{isPolymorphic}, _isConst{isConst} {};

  ObjectWrapperTImpl(const ObjectWrapperTImpl<void> &);

  bool IsPolymorphic() { return _isPolymorphic; }

  bool IsConst() { return _isConst; }

  const std::type_info &GetObjType() { return _type; }

  void WrapNothing() { _dataObjPtr = nullptr; }

  bool WrapsSomething() { return _dataObjPtr; }

  void *GetObjAddress() { return _dataObjPtr; }

  bool WrapObject(void *address, const std::type_info &type, bool own, bool isPolymorphic, bool isConst);

protected:
  void *_dataObjPtr;
  const std::type_info &_type;
  bool _isPolymorphic;
  bool _isConst;
};

template <typename DataType, typename = void> class ObjectWrapperT : public ObjectWrapperTImpl<DataType> {
  using ObjectWrapperTImpl<DataType>::ObjectWrapperTImpl;

public:
  std::unique_ptr<ObjectWrapperBase> CloneObject() {
    throw std::logic_error("Call to ObjectWrapperT::CloneObject for non-copy-constructible class");
  }

  std::unique_ptr<ObjectWrapperBase> CloneWrapper() {
    return std::unique_ptr<ObjectWrapperBase>(new ObjectWrapperT<DataType>(*this));
  }
};

template <typename DataType>
class ObjectWrapperT<DataType, typename std::enable_if<smart_is_copy_constructible<DataType>::value>::type>
    : public ObjectWrapperTImpl<DataType> {

public:
  using ObjectWrapperTImpl<DataType>::ObjectWrapperTImpl;

  std::unique_ptr<ObjectWrapperBase> CloneObject();

  std::unique_ptr<ObjectWrapperBase> CloneWrapper() {
    return std::unique_ptr<ObjectWrapperBase>(new ObjectWrapperT<DataType>(*this));
  }
};

} // namespace EA

#include "core/ObjectWrapperT.hpp"

#endif /* OBJECTWRAPPERT_H_ */