cmnClassRegisterMacros.h

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-    */
/* ex: set filetype=cpp softtabstop=4 shiftwidth=4 tabstop=4 cindent expandtab: */

/*

  Author(s):  Anton Deguet
  Created on: 2006-10-30

  (C) Copyright 2006-2012 Johns Hopkins University (JHU), All Rights
  Reserved.

--- begin cisst license - do not edit ---

This software is provided "as is" under an open source license, with
no warranty.  The complete license can be found in license.txt and
http://www.cisst.org/cisst/license.txt.

--- end cisst license ---

*/

#pragma once

#ifndef _cmnClassRegisterMacros_h
#define _cmnClassRegisterMacros_h

#include <cisstCommon/cmnTypeTraits.h>

#ifdef CMN_DECLARE_SERVICES
#undef CMN_DECLARE_SERVICES
#endif
#define CMN_DECLARE_SERVICES(hasDynamicCreation, lod) \
    public: \
      enum {HAS_DYNAMIC_CREATION = hasDynamicCreation}; \
      enum {InitialLoD = lod}; \
      static cmnClassServicesBase * ClassServices(void); \
      virtual const cmnClassServicesBase * Services(void) const; \
    private: \
      static cmnClassServicesBase * ClassServicesPointer;



#ifdef CMN_DECLARE_SERVICES_EXPORT
#undef CMN_DECLARE_SERVICES_EXPORT
#endif
#define CMN_DECLARE_SERVICES_EXPORT(hasDynamicCreation, lod) \
    public: \
      enum {HAS_DYNAMIC_CREATION = hasDynamicCreation}; \
      enum {InitialLoD = lod}; \
      CISST_EXPORT static cmnClassServicesBase * ClassServices(void); \
      virtual CISST_EXPORT const cmnClassServicesBase * Services(void) const; \
    private: \
      static cmnClassServicesBase * ClassServicesPointer;

#ifdef CMN_DECLARE_SERVICES_EXPORT_ALWAYS
#undef CMN_DECLARE_SERVICES_EXPORT_ALWAYS
#endif
#if WIN32 && _MSC_VER && CISST_DLL
#define CMN_DECLARE_SERVICES_EXPORT_ALWAYS(hasDynamicCreation, lod) \
    public: \
      enum {HAS_DYNAMIC_CREATION = hasDynamicCreation}; \
      enum {InitialLoD = lod}; \
      _declspec(dllexport) static cmnClassServicesBase * ClassServices(void); \
      virtual _declspec(dllexport) const cmnClassServicesBase * Services(void) const; \
    private: \
      static cmnClassServicesBase * ClassServicesPointer;
#else
#define CMN_DECLARE_SERVICES_EXPORT_ALWAYS(hasDynamicCreation, lod) CMN_DECLARE_SERVICES_EXPORT(hasDynamicCreation, lod)
#endif




#ifdef CMN_DECLARE_SERVICES_INSTANTIATION
#undef CMN_DECLARE_SERVICES_INSTANTIATION
#endif
#define CMN_DECLARE_SERVICES_INSTANTIATION(className) \
template<> \
cmnClassServicesBase * cmnClassServicesInstantiate<className>(void);

#ifdef CMN_DECLARE_SERVICES_INSTANTIATION_EXPORT
#undef CMN_DECLARE_SERVICES_INSTANTIATION_EXPORT
#endif
#define CMN_DECLARE_SERVICES_INSTANTIATION_EXPORT(className) \
template<> CISST_EXPORT \
cmnClassServicesBase * cmnClassServicesInstantiate<className>(void);




#ifndef LIBRARY_NAME_FOR_CISST_REGISTER
#define LIBRARY_NAME_FOR_CISST_REGISTER ""
#endif

#ifdef CMN_IMPLEMENT_SERVICES
#undef CMN_IMPLEMENT_SERVICES
#endif
#define CMN_IMPLEMENT_SERVICES_INTERNAL(className, parentServices, argType) \
cmnClassServicesBase * className::ClassServices(void) \
{ \
    static cmnClassServicesBase * classServices = cmnClassServicesInstantiate<className>(); \
    return classServices; \
} \
cmnClassServicesBase * className::ClassServicesPointer = className::ClassServices(); \
const cmnClassServicesBase * className::Services(void) const    \
{ \
    return this->ClassServices(); \
} \
template<> \
cmnClassServicesBase * cmnClassServicesInstantiate<className>(void) \
{ \
    static cmnClassServices<className::HAS_DYNAMIC_CREATION, className, argType> \
        classServices(#className, &typeid(className), parentServices, LIBRARY_NAME_FOR_CISST_REGISTER, className::InitialLoD); \
    return static_cast<cmnClassServicesBase *>(&classServices); \
} \
static cmnClassServicesBase * className##ClassServicesPointer = className::ClassServices();

#define CMN_IMPLEMENT_SERVICES(className) \
    CMN_IMPLEMENT_SERVICES_INTERNAL(className, 0, className)

#define CMN_IMPLEMENT_SERVICES_DERIVED(className, parentName) \
            CMN_IS_DERIVED_FROM_ASSERT(className, parentName) \
            CMN_IMPLEMENT_SERVICES_INTERNAL(className, parentName::ClassServices(), className)

#ifdef CMN_IMPLEMENT_SERVICES_TEMPLATED
#undef CMN_IMPLEMENT_SERVICES_TEMPLATED
#endif
#define CMN_IMPLEMENT_SERVICES_TEMPLATED_INTERNAL(className, parentServices, argType) \
template<> \
cmnClassServicesBase * className::ClassServices(void) \
{ \
    static cmnClassServicesBase * classServices = cmnClassServicesInstantiate<className>(); \
    return classServices; \
} \
template<> \
cmnClassServicesBase * className::ClassServicesPointer = className::ClassServices(); \
template<> \
const cmnClassServicesBase * className::Services(void) const \
{ \
   return this->ClassServices(); \
} \
template<> \
cmnClassServicesBase * cmnClassServicesInstantiate<className>(void) \
{ \
    static cmnClassServices<className::HAS_DYNAMIC_CREATION, className, argType> \
        classServices(#className, &typeid(className), parentServices, LIBRARY_NAME_FOR_CISST_REGISTER, className::InitialLoD); \
    return static_cast<cmnClassServicesBase *>(&classServices); \
} \
static cmnClassServicesBase * className##ClassServicesPointer = className::ClassServices();

#define CMN_IMPLEMENT_SERVICES_TEMPLATED(className) \
        CMN_IMPLEMENT_SERVICES_TEMPLATED_INTERNAL(className, 0, className)

#define CMN_IMPLEMENT_SERVICES_DERIVED_TEMPLATED(className, parentName) \
            CMN_IS_DERIVED_FROM_ASSERT(className, parentName) \
            CMN_IMPLEMENT_SERVICES_TEMPLATED_INTERNAL(className, parentName::ClassServices(), className)



/* This parameter allows to either register a class without dynamic
  creation (just for logging, usually a "processing" class) or
  register the class with dynamic creation (the log is still
  available, mostly for "data" objects).  Dynamic creation can be used
  to create an object of a given type based on its name provided as a
  string.

  It is important to note that a class registered to allow dynamic
  creation must provide a default constructor.  The C++ compiler will
  not be able to compile the code generated if the default constructor
  is missing.
*/

// Possible options for dynamic creation
const int CMN_NO_DYNAMIC_CREATION = 0;       // no dynamic creation
const int CMN_DYNAMIC_CREATION_DEFAULT = 1;  // dynamic creation with default constructor
const int CMN_DYNAMIC_CREATION_COPY = 2;     // dynamic creation with copy constructor
const int CMN_DYNAMIC_CREATION = 3;          // dynamic creation with default and/or copy constructor (backward compatibility)
const int CMN_DYNAMIC_CREATION_SETNAME = 5;  // dynamic creation with default constructor and SetName method
const int CMN_DYNAMIC_CREATION_ONEARG = 8;   // dynamic creation with one argument constructor (but not copy constructor)


#endif // _cmnClassRegisterMacros_h