typeinterface.hpp

Go to the documentation of this file.

#pragma once
/*
**  Copyright (C) 2013 Aldebaran Robotics
**  See COPYING for the license
*/

#ifndef _QITYPE_DETAIL_TYPEINTERFACE_HPP_
#define _QITYPE_DETAIL_TYPEINTERFACE_HPP_

#include <typeinfo>
#include <string>
#include <qi/api.hpp>
#include <qi/signature.hpp>

/* A lot of class are found in this headers... to kill circular dependencies.
   Futhermore we need that all "default template" types are registered (included)
   when type.hpp is used. (for typeOf to works reliably)
*/


#ifdef _MSC_VER
#  pragma warning( push )
#  pragma warning( disable: 4251 )
#endif

namespace qi {


  class QI_API TypeInfo
  {
  public:
    TypeInfo();
    TypeInfo(const std::type_info& info);
    TypeInfo(const std::string& ti);

    std::string asString() const;
    std::string asDemangledString() const;

    //TODO: DIE
    const char* asCString() const;

    bool operator==(const TypeInfo& b) const;
    bool operator!=(const TypeInfo& b) const;
    bool operator<(const TypeInfo& b) const;

  private:
    const std::type_info* stdInfo;
    // C4251
    std::string           customInfo;
  };

  class QI_API TypeInterface
  {
  public:
    virtual const TypeInfo& info() =0;

    virtual void* initializeStorage(void* ptr=0)=0;

    // Use a pointer and not a reference to avoid the case where the compiler makes a copy on the stack
    virtual void* ptrFromStorage(void**)=0;

    virtual void* clone(void*)=0;
    virtual void destroy(void*)=0;

    virtual TypeKind kind();

    virtual bool less(void* a, void* b) = 0;

    //TODO: DIE
    inline const char* infoString() { return info().asCString(); } // for easy gdb access

    qi::Signature signature(void* storage=0, bool resolveDynamic = false);

    static TypeInterface* fromSignature(const qi::Signature& sig);
  };

  QI_API TypeInterface*  getType(const std::type_info& type);

  QI_API bool registerType(const std::type_info& typeId, TypeInterface* type);

  template<typename T> TypeInterface* typeOf();

  template<typename T> TypeInterface* typeOf(const T& v)
  {
    return typeOf<T>();
  }

  QI_API void registerStruct(TypeInterface* type);
  QI_API TypeInterface* getRegisteredStruct(const qi::Signature& s);
}


#ifdef _MSC_VER
#  pragma warning( pop )
#endif

#endif  // _QITYPE_DETAIL_TYPEINTERFACE_HPP_