berryExtensionType.h

Go to the documentation of this file.

/*===================================================================

BlueBerry Platform

Copyright (c) German Cancer Research Center,
Division of Medical and Biological Informatics.
All rights reserved.

This software is distributed WITHOUT ANY WARRANTY; without
even the implied warranty of MERCHANTABILITY or FITNESS FOR
A PARTICULAR PURPOSE.

See LICENSE.txt or http://www.mitk.org for details.

===================================================================*/

#ifndef BERRY_EXTENSION_TYPES_H
#define BERRY_EXTENSION_TYPES_H

#include <org_blueberry_core_runtime_Export.h>

#include <QObject>

namespace berry {

class org_blueberry_core_runtime_EXPORT ExtensionType
{

public:

  typedef void (*Destructor)(QObject *);
  typedef QObject* (*Constructor)();

  static int registerType(const char* typeName, Destructor destructor,
                          Constructor constructor);

  static int registerTypedef(const char* typeName, int aliasId);

  static void unregisterType(const char* typeName);

  static int type(const char* typeName);

  static const char* typeName(int type);

  static bool isRegistered(int type);

  static QObject* construct(int type);

  static void destroy(int type, QObject* data);
};

template <typename T>
void extensionTypeDeleteHelper(T* t)
{
  delete t;
}

template <typename T>
QObject* extensionTypeConstructHelper(const T* /*t*/)
{
  return new T;
}

template <typename T>
struct ExtensionTypeId
{
  enum { Defined = 0 };
};

template <typename T>
struct ExtensionTypeId2
{
  enum { Defined = ExtensionTypeId<T>::Defined };
  static inline int extensiontype_id() { return ExtensionTypeId<T>::extensiontype_id(); }
};

namespace internal {

template <typename T, bool Defined = ExtensionTypeId2<T>::Defined>
struct ExtensionTypeIdHelper
{
  static inline int extensiontype_id()
  { return ExtensionTypeId2<T>::extensiontype_id(); }
};

template <typename T>
struct ExtensionTypeIdHelper<T, false>
{
  static inline int extensiontype_id()
  { return -1; }
};

} // end namespace internal

template <typename T>
int registerExtensionType(const char* typeName
#ifndef DOXYGEN_SKIP
                          , T* dummy = 0
#endif
)
{
  const int typedefOf = dummy ? -1 : internal::ExtensionTypeIdHelper<T>::extensiontype_id();
  if (typedefOf != -1)
    return ExtensionType::registerTypedef(typeName, typedefOf);

  typedef QObject*(*ConstructPtr)(const T*);
  ConstructPtr cptr = extensionTypeConstructHelper<T>;
  typedef void(*DeletePtr)(T*);
  DeletePtr dptr = extensionTypeDeleteHelper<T>;

  return ExtensionType::registerType(typeName, reinterpret_cast<ExtensionType::Destructor>(dptr),
                                     reinterpret_cast<ExtensionType::Constructor>(cptr));
}

} // end namespace berry


#endif // BERRY_EXTENSION_TYPES_H