typeinterface.hpp

Go to the documentation of this file.

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

#ifndef _QI_TYPE_TYPEINTERFACE_HPP_
#define _QI_TYPE_TYPEINTERFACE_HPP_

#include <typeinfo>
#include <string>

#include <boost/preprocessor.hpp>
#include <boost/function.hpp>
#include <boost/type_traits/is_function.hpp>
#include <boost/mpl/if.hpp>

#include <qi/log.hpp>
#include <qi/api.hpp>
#include <qi/type/fwd.hpp>
#include <qi/signature.hpp>
#include <qi/type/detail/typeinterface.hpp>

#ifdef _MSC_VER
#  pragma warning( push )
#  pragma warning( disable: 4251 )
   // C4503 decorated name length exceeded, name was truncated
   // The only workaround is to make structs to hide the template complexity
   // We don't want to have to do that
#  pragma warning( disable: 4503 )
#endif

/* 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)
*/

namespace qi{

  #define QI_TYPE_NOT_CONSTRUCTIBLE(T) \
    namespace qi { namespace detail {  \
    template<> struct TypeManager<T>: public TypeManagerNotConstructible<T> {};}}

  #define QI_NO_TYPE(T) namespace qi {template<> class TypeImpl<T>: public detail::ForbiddenInTypeSystem {};}

  #define QI_TYPE_INTERFACE(T)     \
    namespace qi { namespace detail { \
    template<> struct TypeManager<T>: public TypeManagerDefaultInterface<T> {};}}

  #define QI_TYPE_CONCRETE(T)     \
    namespace qi { namespace detail { \
    template<> struct TypeManager<T>: public TypeManagerDefaultStruct<T> {}; }}

  #define QI_TYPE_REGISTER(t) \
    QI_TYPE_REGISTER_CUSTOM(t, qi::TypeImpl<t>)

  #define QI_TYPE_REGISTER_CUSTOM(type, typeimpl) \
    static bool BOOST_PP_CAT(__qi_registration, __LINE__) = qi::registerType(typeid(type), new typeimpl)


  class ListTypeInterface;
  class StructTypeInterface;

  // Interfaces for specialized types
  class QI_API IntTypeInterface: public TypeInterface
  {
  public:
    virtual int64_t get(void* value) = 0;
    virtual unsigned int size() = 0;
    virtual bool isSigned() = 0;
    virtual void set(void** storage, int64_t value) = 0;
    TypeKind kind() override { return TypeKind_Int;}
  };

  class QI_API FloatTypeInterface: public TypeInterface
  {
  public:
    virtual double get(void* value) = 0;
    virtual unsigned int size() = 0; // size in bytes
    virtual void set(void** storage, double value) = 0;
    TypeKind kind() override { return TypeKind_Float;}
  };

  class QI_API StringTypeInterface: public TypeInterface
  {
  public:
    using RawString = std::pair<char*, size_t>;
    using Deleter = boost::function<void(const RawString&)>;
    using ManagedRawString = std::pair<RawString, Deleter>;

    std::string getString(void* storage);
    virtual ManagedRawString get(void* storage) = 0;
    void set(void** storage, const std::string& value);
    virtual void set(void** storage, const char* ptr, size_t sz) = 0;
    TypeKind kind() override { return TypeKind_String; }

  };

  class QI_API RawTypeInterface: public TypeInterface
  {
  public:
    virtual std::pair<char*, size_t> get(void* storage) = 0;
    virtual void set(void** storage, const char* ptr, size_t sz) = 0;
    TypeKind kind() override { return TypeKind_Raw; }
  };

  class QI_API PointerTypeInterface: public TypeInterface
  {
  public:
    enum PointerKind
    {
      Raw,
      Shared,
    };
    virtual PointerKind pointerKind() = 0;
    virtual TypeInterface* pointedType() = 0;
    virtual AnyReference dereference(void* storage) = 0;
    virtual void set(void** storage, AnyReference pointer) = 0;
    virtual void setPointee(void** storage, void* pointer) = 0;
    TypeKind kind() override { return TypeKind_Pointer; }
  };

  class QI_API IteratorTypeInterface: public TypeInterface
  {
  public:
    virtual AnyReference dereference(void* storage) = 0;
    virtual void next(void** storage) = 0;
    virtual bool equals(void* s1, void* s2) = 0;
    TypeKind kind() override { return TypeKind_Iterator; }
  };

  class QI_API ListTypeInterface: public TypeInterface
  {
  public:
    virtual TypeInterface* elementType() = 0;
    virtual size_t size(void* storage) = 0;
    virtual AnyIterator begin(void* storage) = 0;
    virtual AnyIterator end(void* storage) = 0;
    virtual void pushBack(void** storage, void* valueStorage) = 0;
    virtual void* element(void* storage, int index);
    TypeKind kind() override { return TypeKind_List;}
  };

  class QI_API MapTypeInterface: public TypeInterface
  {
  public:
    virtual TypeInterface* elementType() = 0;
    virtual TypeInterface* keyType() = 0;
    virtual size_t size(void* storage) = 0;
    virtual AnyIterator begin(void* storage) = 0;
    virtual AnyIterator end(void* storage) = 0;
    virtual void insert(void** storage, void* keyStorage, void* valueStorage) = 0;
    virtual AnyReference element(void** storage, void* keyStorage, bool autoInsert) = 0;
    TypeKind kind() override { return TypeKind_Map; }
    // Since our typesystem has no erased operator < or operator ==,
    // MapTypeInterface does not provide a find()
  };

  class QI_API StructTypeInterface: public TypeInterface
  {
  public:
    AnyReferenceVector values(void* storage);
    virtual std::vector<TypeInterface*> memberTypes() = 0;
    virtual std::vector<void*> get(void* storage);
    virtual void* get(void* storage, unsigned int index) = 0;
    virtual void set(void** storage, const std::vector<void*>&);
    virtual void set(void** storage, unsigned int index, void* valStorage) = 0;
    TypeKind kind() override { return TypeKind_Tuple; }
    virtual std::vector<std::string> elementsName() { return std::vector<std::string>();}
    virtual std::string className() { return std::string(); }

    virtual bool convertFrom(std::map<std::string, ::qi::AnyValue>& fields,
                             const std::vector<std::tuple<std::string, TypeInterface*>>& missing,
                             const std::map<std::string, ::qi::AnyReference>& dropfields)
    {
      return false;
    }
    virtual bool convertTo(std::map<std::string, ::qi::AnyValue>& fields,
                           const std::vector<std::tuple<std::string, TypeInterface*>>& missing,
                           const std::map<std::string, ::qi::AnyReference>& dropfields)
    {
      return false;
    }

  };

  class QI_API DynamicTypeInterface: public TypeInterface
  {
  public:
    virtual AnyReference get(void* storage) = 0;
    virtual void set(void** storage, AnyReference source) = 0;
    TypeKind kind() override { return TypeKind_Dynamic; }
  };

  class QI_API VarArgsTypeInterface: public ListTypeInterface
  {
  public:
    //virtual AnyReference get(void *storage) = 0;
    //virtual TypeInterface* elementType() = 0;
    TypeKind kind() override { return TypeKind_VarArgs; }
  };

  QI_API TypeInterface* makeTypeOfKind(const qi::TypeKind& kind);

  QI_API TypeInterface* makeFloatType(int bytelen);

  QI_API TypeInterface* makeIntType(bool issigned, int bytelen);

  QI_API TypeInterface* makeVarArgsType(TypeInterface* elementType);

  QI_API TypeInterface* makeListType(TypeInterface* elementType);

  QI_API TypeInterface* makeMapType(TypeInterface* keyType, TypeInterface* ElementType);

  QI_API TypeInterface* makeTupleType(const std::vector<TypeInterface*>& memberTypes, const std::string &name = std::string(), const std::vector<std::string>& elementNames = std::vector<std::string>());



#define QI_TEMPLATE_TYPE_DECLARE(n)                                           \
  namespace qi                                                                \
  {                                                                           \
  template <typename T>                                                       \
  class QITYPE_TEMPLATE_API TypeImpl<n<T> > : public TypeOfTemplateImpl<n, T> \
  {                                                                           \
  };                                                                          \
  }

#define QI_TEMPLATE_TYPE_GET(typeInst, templateName) \
  dynamic_cast< ::qi::TypeOfTemplate<templateName>*>(typeInst)

#define QI_TYPE_ENUM(Enum)                                  \
  namespace qi                                              \
  {                                                         \
    template <>                                             \
    class TypeImpl<Enum> : public IntTypeInterfaceImpl<int> \
    {                                                       \
    };                                                      \
  }

namespace detail
{
  struct QI_API_DEPRECATED_MSG(Use 'QI_TYPE_ENUM' instead) QI_TYPE_ENUM_REGISTER_ {};
}

#define QI_TYPE_ENUM_REGISTER(Enum)                                  \
  namespace qi                                                       \
  {                                                                  \
    template <>                                                      \
    class TypeImpl<Enum> : public IntTypeInterfaceImpl<int>          \
    {                                                                \
      static const detail::QI_TYPE_ENUM_REGISTER_ BLAH;              \
    };                                                               \
  }

#define QI_TYPE_STRUCT_DECLARE(name)                                      \
 __QI_TYPE_STRUCT_DECLARE(name, )

}


#include <qi/type/detail/typeimpl.hxx>
#include <qi/type/detail/type.hxx>
#include <qi/type/detail/inttypeinterface.hxx>
#include <qi/type/detail/listtypeinterface.hxx>
#include <qi/type/detail/maptypeinterface.hxx>
#include <qi/type/detail/stringtypeinterface.hxx>
#include <qi/type/detail/pointertypeinterface.hxx>
#include <qi/type/detail/structtypeinterface.hxx>
#include <qi/type/detail/buffertypeinterface.hxx>
#include <qi/type/detail/dynamictypeinterface.hxx>

QI_NO_TYPE(qi::TypeInterface)
QI_NO_TYPE(qi::TypeInterface*)

#ifdef _MSC_VER
#  pragma warning( pop )
// restore the disabling of this warning
#  pragma warning( disable: 4503 )
#endif

#endif  // _QITYPE_TYPEINTERFACE_HPP_