MBEntityType.h

Go to the documentation of this file.

#ifndef MB_ENTITY_TYPE_H
#define MB_ENTITY_TYPE_H

/* This file can be used to define several different things.
 *
 * A) If included in C code (not C++), it defines:
 *    1) An enum named MBEntityType, guarded by the MB_ENTITY_TYPE_H
 *        include guards and 
 *    2) a typedef MBEntityType guarded by MOAB_ENTITY_TYPE_C include guards.
 *
 * B) If included in C++ code, it defines:
 *    1) An enum named EntiyType in the MOAB namespace, guarded
 *       by the MB_ENTITY_TYPE include guards
 *    2) Increment and decrement oeprators for the moab::EntityType enum,
 *       also guarded by the MB_ENTITY_TYPE include guards
 *    3) A typedef for moab::EntityType in the global namespace 
 *        named MBEntityType, guarded by the MOAB_ENTITY_TYPE_NS_ONLY
 *        include guards
 *
 * The C and C++ code should be entirely independent.  They are defined
 * in the same file only to avoid code duplication and inconsistent enum
 * values.  OTOH, the C++ definitions must be in the same file because
 * the compiler must treat both the namespaced and non-namespaced names
 * as the same type.
 *
 * The C++ code must be able to provide:
 *  a) An enum in the moab namespace
 *  b) An enum in the global namespace that is the *same type*
 *      as a) as far as the compiler is concerned.
 *  c) Nothing in the global namespace unless requested
 *  d) No breakage if both namespaced and non-namespaced headers
 *      are both included.
 * 
 * This is acheived with the somewhat complicated set of multiple
 * included guards described above, where moab/EntityType.hpp will
 * include this file with MOAB_ENTITY_TYPE_NS_OLNY temporarily defined
 * so as to pull in only the namespaced version at that time, without
 * prohibiting the non-namespaced version from being pulled in previously
 * or later.
 */
#ifdef __cplusplus
namespace moab { 
# define MOAB_ENTITY_TYPE_NAME EntityType
# else /* __cplusplus */
# define MOAB_ENTITY_TYPE_NAME MBEntityType
#endif /* __cplusplus */

enum MOAB_ENTITY_TYPE_NAME
{
  MBVERTEX = 0, 
  MBEDGE,       
  MBTRI,        
  MBQUAD,       
  MBPOLYGON,    
  MBTET,        
  MBPYRAMID,    
  MBPRISM,      
  MBKNIFE,      
  MBHEX,        
  MBPOLYHEDRON, 
  MBENTITYSET,    
  MBMAXTYPE  
};

#ifdef __cplusplus

inline MOAB_ENTITY_TYPE_NAME & operator++(MOAB_ENTITY_TYPE_NAME &type)
{
  return type = static_cast<MOAB_ENTITY_TYPE_NAME>(type+1);
}

inline MOAB_ENTITY_TYPE_NAME operator++(MOAB_ENTITY_TYPE_NAME &type, int)
{
  MOAB_ENTITY_TYPE_NAME oldval = type;
  ++type;
  return oldval;
}

inline MOAB_ENTITY_TYPE_NAME & operator--(MOAB_ENTITY_TYPE_NAME &type)
{
  return type = static_cast<MOAB_ENTITY_TYPE_NAME>(type-1);
}

inline MOAB_ENTITY_TYPE_NAME operator--(MOAB_ENTITY_TYPE_NAME &type, int)
{
  MOAB_ENTITY_TYPE_NAME oldval = type;
  --type;
  return oldval;
}

} /* namespace moab*/
#endif /* __cplusplus */

#undef MOAB_ENTITY_TYPE_NAME
#endif /* MB_ENTITY_TYPE_H */

#ifdef __cplusplus
#  ifndef MOAB_ENTITY_TYPE_NS_ONLY
#    define MOAB_ENTITY_TYPE_NS_ONLY
     typedef moab::EntityType MBEntityType;
     using moab::MBVERTEX;
     using moab::MBEDGE;
     using moab::MBTRI;
     using moab::MBQUAD;
     using moab::MBPOLYGON;
     using moab::MBTET;
     using moab::MBPYRAMID;
     using moab::MBPRISM;
     using moab::MBKNIFE;
     using moab::MBHEX;
     using moab::MBPOLYHEDRON;
     using moab::MBENTITYSET;
     using moab::MBMAXTYPE;
#  endif /* MOAB_ENTITY_TYPE_NS_ONLY */
#else /* __cplusplus */
#  ifndef MOAB_ENTITY_TYPE_C
#    define MOAB_ENTITY_TYPE_C
     typedef enum MBEntityType MBEntityType;
#  endif /* MOAB_ENTITY_TYPE_C */
#endif /* __cplusplus */