albaDefines.h

Go to the documentation of this file.

/*=========================================================================
 
 Program: ALBA (Agile Library for Biomedical Applications)
 Module: albaDefines
 Authors: Marco Petrone, Gianluigi Crimi
 
 Copyright (c) BIC
 All rights reserved. See Copyright.txt or
 
 
 This software is distributed WITHOUT ANY WARRANTY; without even
 the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 PURPOSE.  See the above copyright notice for more information.
 
=========================================================================*/
#ifndef __albaDefines_h
#define __albaDefines_h
 
//----------------------------------------------------------------------------
// Pragmas: disable the "singned/unsigned mismatch" warning
//----------------------------------------------------------------------------
#pragma warning( disable : 4018 )
#pragma warning( disable : 4251 )
 
 
 
//----------------------------------------------------------------------------
// Includes: albaConfigure should be first, albaIncludeWX second
//----------------------------------------------------------------------------
#include <mutex>
#include <string.h>
#include <typeinfo>
#include <iosfwd>
#include <sstream>
 
#include "albaConfigure.h"
#include "albaIncludeWX.h" // must be after albaConfigure.h
 
 
//----------------------------------------------------------------------------
// forward declarations :
//----------------------------------------------------------------------------
#ifndef MIN 
   #define MIN( x, y ) ( (x) < (y) ? (x) : (y) )
#endif
#ifndef MAX 
   #define MAX( x, y ) ( (x) > (y) ? (x) : (y) )
#endif
#ifndef round
   #define round(x) (x<0?ceil((x)-0.5):floor((x)+0.5))
#endif
 
//------------------------------------------------------------------------------
// Typedefs
//------------------------------------------------------------------------------
typedef double albaTimeStamp; 
typedef long albaID; 
typedef std::type_info albaTypeID; 
 
//------------------------------------------------------------------------------
// Constants
//------------------------------------------------------------------------------
enum ALBA_EXPORT ALBA_RETURN_VALUES_ID
{
  ALBA_OK = 0,
  ALBA_ERROR,
  ALBA_WAIT,
  ALBA_USER_RETURN_VALUE
};
#define ID_NO_EVENT 0
/*enum ALBA_NO_EVENT_ID
{
  ID_NO_EVENT = 0
};
*/
#define ALBA_STRING_BUFFER_SIZE 2048
/*enum ALBA_DEFAULT_BUFFER_SIZE
{
  ALBA_STRING_BUFFER_SIZE = 2048
};
*/
//------------------------------------------------------------------------------
// Global Variables
//------------------------------------------------------------------------------
 
//------------------------------------------------------------------------------
// Global Functions
//------------------------------------------------------------------------------
ALBA_EXPORT void albaLogMessage(const char *format, ...);
ALBA_EXPORT void albaWarningMessage(const char *format, ...);
ALBA_EXPORT void albaErrorMessage(const char *format, ...);
ALBA_EXPORT void albaMessage(const char *format, ...);
ALBA_EXPORT bool albaEquals(double x, double y);
ALBA_EXPORT bool albaFloatEquals(float x, float y);
 
ALBA_EXPORT double albaRoundToPrecision(double val, unsigned prec);
 
ALBA_EXPORT bool albaIsLittleEndian(void);
 
ALBA_EXPORT void albaSleep(int msec);
 
//------------------------------------------------------------------------------
// Macros
//------------------------------------------------------------------------------
 
#define vtkDEL(a) do{if (a) { a->Delete(); a = NULL; }}while(0)
 
#define vtkNEW(a) a=a->New()
 
#define albaNEW(a) do{a=a->New();a->Register(this);}while(0)
 
#define albaDEL(a) do{if (a) { a->Delete(); a = NULL;}}while(0)
 
#define cppDEL(a) do{if (a) { delete a; a = NULL;}}while(0)
 
#define albaAbstractTypeMacro(thisClass,superclass) \
  public: \
 \
  typedef superclass Superclass; \
 \
  static const albaTypeID &GetStaticTypeId(); \
 \
  virtual const albaTypeID &GetTypeId() const; \
 \
  static const char *GetStaticTypeName(); \
 \
  virtual const char *GetTypeName() const; \
 \
  static bool IsStaticType(const char *type); \
 \
  static bool IsStaticType(const albaTypeID &type); \
 \
  virtual bool IsA(const char *type) const; \
 \
  virtual bool IsA(const albaTypeID &type) const; \
 \
  static thisClass* SafeDownCast(albaObject *o);
 
#define albaTypeMacro(thisClass,superclass) \
  albaAbstractTypeMacro(thisClass,superclass); \
  \
  static albaObject *NewObject(); \
 \
  virtual albaObject *NewObjectInstance() const; \
 \
  thisClass *NewInstance() const; \
 \
  static thisClass *New();
  
#define albaCxxAbstractTypeMacro(thisClass) \
  const albaTypeID &thisClass::GetStaticTypeId() {return typeid(thisClass);} \
  const albaTypeID &thisClass::GetTypeId() const {return typeid(thisClass);} \
  const char *thisClass::GetStaticTypeName() {return #thisClass;} \
  const char *thisClass::GetTypeName() const {return #thisClass;} \
  bool thisClass::IsStaticType(const char *type) \
  { return ( strcmp(#thisClass,type)==0 ) ? true : Superclass::IsStaticType(type); } \
  bool thisClass::IsStaticType(const albaTypeID &type) \
  { return ( type==typeid(thisClass) ? true : Superclass::IsStaticType(type) ); } \
  bool thisClass::IsA(const char *type) const {return IsStaticType(type);} \
  bool thisClass::IsA(const albaTypeID &type) const {return IsStaticType(type);} \
  thisClass* thisClass::SafeDownCast(albaObject *o) \
  { try { return dynamic_cast<thisClass *>(o); } catch (std::bad_cast) { return NULL;} }
 
#define albaCxxTypeMacro(thisClass) \
  albaCxxAbstractTypeMacro(thisClass); \
  albaObject *thisClass::NewObject() \
  { \
    thisClass *obj = new thisClass; \
    if (obj) obj->m_HeapFlag=true; \
    return obj; \
  } \
  albaObject *thisClass::NewObjectInstance() const \
  { return NewObject(); } \
  thisClass *thisClass::New() \
  { return (thisClass *)NewObject(); } \
  thisClass *thisClass::NewInstance() const \
  { return (thisClass *)NewObjectInstance(); }
 
#define IsALBAType(type_name) IsA(type_name::GetStaticTypeId())
 
#define ALBA_ID_IMP(idname) const albaID idname = mmuIdFactory::GetNextId(#idname);
#define ALBA_ID_DEC(idname) static const albaID idname;
#define ALBA_ID_GLOBAL(idname) extern const albaID idname;
 
// Not Used !!
//#define ALBA_ID_GROUP(groupname,num) const albaID groupname = mmuIdFactory::AllocIdGroup(#groupname,num);
 
#define ALBA_ID_CLASS_DEC(baseClass) static const albaID BaseID;
#define ALBA_ID_CLASS_IMP(baseClass,num) const albaID baseClass::BaseID = mmuIdFactory::AllocIdGroup("#baseClass::BaseID",num);
 
#define ALBA_ID_LOC(name,idname) static const albaID name=mmuIdFactory::GetId(#idname);
 
#define albaGetEventClassId(event,baseClass) (event->GetID()-baseClass::BaseID)
#define albaGetEventGroupId(event,baseID) (event->GetID()-baseID)
#define albaEvalGroupId(baseClass,id) (baseClass::BaseID+id)
 
#define albaEventMacro(e)  if (m_Listener) {m_Listener->OnEvent(&e);}
  
#define ALBA_TEST(a) if (!(a)) \
{ \
  std::cerr << "Test failed at line " \
  << __LINE__ << " : " << #a << std::endl; \
  return ALBA_ERROR; \
}
 
#define albaWarningMacro(x) \
{ \
  std::stringstream msg; \
  msg << "Warning in: " __FILE__ ", line " << __LINE__ << "\n" x \
    << "\n"; \
  albaLogMessage(msg.str().c_str());\
}
 
#define albaErrorMacro(x) \
{ \
  std::stringstream msg; \
  msg << "Error in: " __FILE__ ", line " << __LINE__ << "\n" x \
    << "\n"; \
  albaLogMessage(msg.str().c_str());\
}
 
#define albaWarningMessageMacro(x) \
{ \
  std::stringstream msg; \
  msg << x << "\n"; \
  albaWarningMessage(msg.str().c_str());\
}
 
#define albaErrorMessageMacro(x) \
{ \
  std::stringstream msg; \
  msg << x << "\n"; \
  albaErrorMessage(msg.str().c_str());\
}
 
#define albaMessageMacro(x) \
{ \
  std::stringstream msg; \
  msg << x << "\n"; \
  albaMessage(msg.str().c_str());\
}
 
#define ALBA_PRINT_MACRO(format,buffer,size) \
  va_list argptr; \
  va_start(argptr, format); \
  vsnprintf(buffer,(const size_t)size, format, argptr); \
  va_end(argptr);
 
#endif