Cppcheck report - CGM: itaps/iGeom.h

#ifndef _ITAPS_iBase
#define _ITAPS_iBase

/***************************************************************************//**
 * \ingroup VersionNumbers
 * \brief Compile time version number digits
 *
 * iBase maintains a major, minor and patch digit in its version number.
 * Technically speaking, there is not much practical value in patch digit
 * for an interface specification. A patch release is typically only used
 * for bug fix releases. Although it is rare, sometimes a bug fix
 * necessitates an API change. So, we define a patch digit for iMesh.
 *
 * Although each interface in ITAPS has been designed to support its own
 * uniqe version numbers, apart from other ITAPS interfaces, as currently
 * used, we require all ITAPS interfaces to use the same ITAPS-wide version
 * number derived from the version number defined by these three digits.
 ******************************************************************************/
#define IBASE_VERSION_MAJOR 1
#define IBASE_VERSION_MINOR 4
#define IBASE_VERSION_PATCH 1

/***************************************************************************//**
 * \ingroup VersionNumbers
 * \brief Version Comparison
 *
 * Evaluates to true at CPP time if the version of iBase currently being
 * compiled is greater than or equal to the version specified.
 ******************************************************************************/
#define IBASE_VERSION_GE(Maj,Min,Pat) \
    (((IBASE_VERSION_MAJOR==(Maj)) && (IBASE_VERSION_MINOR==(Min)) && (IBASE_VERSION_PATCH>=(Pat))) || \
     ((IBASE_VERSION_MAJOR==(Maj)) && (IBASE_VERSION_MINOR>(Min))) || \
      (IBASE_VERSION_MAJOR>(Maj)))

/***************************************************************************//**
 * \ingroup VersionNumbers
 * \brief Compose compile-time string represention of the version number
 ******************************************************************************/
#define IBASE_VERSION_STRING___(I,X,Y,Z) #I "_Version_" #X "." #Y "." #Z
#define IBASE_VERSION_STRING__(I,X,Y,Z) IBASE_VERSION_STRING___(I,X,Y,Z)
#define IBASE_VERSION_STRING_(I) IBASE_VERSION_STRING__(I,IBASE_VERSION_MAJOR,IBASE_VERSION_MINOR,IBASE_VERSION_PATCH)
#define IBASE_VERSION_STRING IBASE_VERSION_STRING_(iBase)

/***************************************************************************//**
 * \ingroup VersionNumbers
 * \brief Compose compile-time symbol name derived from the version number.
 ******************************************************************************/
#define IBASE_VERSION_TAG__(I,X,Y,Z) I##_Version_##X##_##Y##_##Z
#define IBASE_VERSION_TAG_(I,X,Y,Z) IBASE_VERSION_TAG__(I,X,Y,Z)
#define IBASE_VERSION_TAG(I) IBASE_VERSION_TAG_(I,IBASE_VERSION_MAJOR,IBASE_VERSION_MINOR,IBASE_VERSION_PATCH)

/***************************************************************************//**
 * \ingroup VersionNumbers
 * \brief ITAPS-wide (across all ITAPS APIs) version handling
 ******************************************************************************/
#define ITAPS_VERSION_MAJOR IBASE_VERSION_MAJOR
#define ITAPS_VERSION_MINOR IBASE_VERSION_MINOR
#define ITAPS_VERSION_PATCH IBASE_VERSION_PATCH
#define ITAPS_VERSION_GE(Maj,Min,Pat) IBASE_VERSION_GE(Maj,Min,Pat)
#define ITAPS_VERSION_STRING_(I) IBASE_VERSION_STRING_(I)
#define ITAPS_VERSION_STRING ITAPS_VERSION_STRING_(ITAPS)
#define ITAPS_VERSION_TAG_(I) IBASE_VERSION_TAG(I)
#define ITAPS_VERSION_TAG ITAPS_VERSION_TAG_(I)

/***************************************************************************//**
 * \defgroup EnumIterators Enum-Iterators
 * \ingroup iBase
 * \brief Convenience macros for iterating over all possible values in an enum
 *
 * These convenience macros are provided to facilitate iterating over all
 * possible values in an enumerated type. To use these macros, for example...
 * \code 
 * for (iBase_EntityType i  = IBASE_MINENUM(iBase_EntityType);
 *                       i <= IBASE_MAXENUM(iBase_EntityType);
 *                            IBASE_INCENUM(i,iBase_EntityType))
 * {
 * }
 * \endcode
 * Be aware that some enumerated types include a <em>wild card</em> often used
 * in queries to represent all possible values and you may or may not want to
 * include such a value in your iteration.
 ******************************************************************************/

/***************************************************************************//**
 * \ingroup EnumIterators
 * @{
 ******************************************************************************/
#define IBASE_MINENUM(enumName) enumName ## _MIN
#define IBASE_MAXENUM(enumName) enumName ## _MAX
#define IBASE_NUMENUM(enumName) ((int)IBASE_MAXENUM(enumName) - (int)IBASE_MINENUM(enumName) + 1)
#define IBASE_INCENUM(enumName,I) (I = (enum enumName)((int)I+1))
/** @} */

#ifdef __cplusplus
extern "C" {
#endif

typedef void* iBase_Instance;
typedef struct iBase_EntityHandle_Private* iBase_EntityHandle;
typedef struct iBase_EntitySetHandle_Private* iBase_EntitySetHandle;
typedef struct iBase_TagHandle_Private* iBase_TagHandle;
typedef struct iBase_EntityIterator_Private* iBase_EntityIterator;
typedef struct iBase_EntityArrIterator_Private* iBase_EntityArrIterator;

struct iBase_Error
{
    int error_type;
    char description[120];
};

enum iBase_EntityType {
    iBase_EntityType_MIN = 0,
        /**< facilitates iteration over all values */
    iBase_VERTEX = iBase_EntityType_MIN,
        /**< A topological dimension 0 entity */
    iBase_EDGE,
        /**< A topological dimension 1 entity */
    iBase_FACE,
        /**< A topological dimension 2 entity */
    iBase_REGION,
        /**< A topological dimension 3 entity */
    iBase_ALL_TYPES,
        /**< used only in queires to request information about all types */
    iBase_EntityType_MAX = iBase_ALL_TYPES
        /**< facilitates iteration over all values */
};

enum iBase_AdjacencyCost {
    iBase_AdjacencyCost_MIN = 0,
        /**< facilitates iteration over all values */
    iBase_UNAVAILABLE = iBase_AdjacencyCost_MIN,
        /**< Adjacency information not supported */
    iBase_ALL_ORDER_1,
        /**< No more than local mesh traversal required (i!=j) */
    iBase_ALL_ORDER_LOGN,
        /**< Global tree search (i!=j) */
    iBase_ALL_ORDER_N,
        /**< Global exhaustive search (i!=j) */
    iBase_SOME_ORDER_1,
        /**< Only some adjacency info, local (i!=j) */
    iBase_SOME_ORDER_LOGN,
        /**< Only some adjacency info, tree (i!=j) */
    iBase_SOME_ORDER_N,
        /**< Only some adjacency info, exhaustive (i!=j) */
    iBase_AVAILABLE,
        /**< ALL (intermediate) entities available. (i==j) */
    iBase_AdjacencyCost_MAX = iBase_AVAILABLE
        /**< facilitates iteration over all values */
};

enum iBase_CreationStatus {
    iBase_CreationStatus_MIN = 0,
        /**< facilitates iteration over all values */
    iBase_NEW = iBase_CreationStatus_MIN,
        /**< The entity was newly created */
    iBase_ALREADY_EXISTED,
        /**< The entity already existed and the handle for that
             already existing handle was returned */
    iBase_CREATED_DUPLICATE,
        /**< The entity already existed but a new, duplicate entity was
             nevertheless created */
    iBase_CREATION_FAILED,
        /**< Creation of the entity did not succeed */
    iBase_CreationStatus_MAX = iBase_CREATION_FAILED
        /**< facilitates iteration over all values */
};

enum iBase_ErrorType {
    iBase_ErrorType_MIN = 0,
        /**< facilitates iteration over all values */
    iBase_SUCCESS = iBase_ErrorType_MIN,
    iBase_MESH_ALREADY_LOADED,
    iBase_FILE_NOT_FOUND,
    iBase_FILE_WRITE_ERROR,
    iBase_NIL_ARRAY,
    iBase_BAD_ARRAY_SIZE,
    iBase_BAD_ARRAY_DIMENSION,
    iBase_INVALID_ENTITY_HANDLE,
    iBase_INVALID_ENTITY_COUNT,
    iBase_INVALID_ENTITY_TYPE,
    iBase_INVALID_ENTITY_TOPOLOGY,
    iBase_BAD_TYPE_AND_TOPO,
    iBase_ENTITY_CREATION_ERROR,
    iBase_INVALID_TAG_HANDLE,
    iBase_TAG_NOT_FOUND,
    iBase_TAG_ALREADY_EXISTS,
    iBase_TAG_IN_USE,
    iBase_INVALID_ENTITYSET_HANDLE,
    iBase_INVALID_ITERATOR_HANDLE,
    iBase_INVALID_ARGUMENT,
    iBase_MEMORY_ALLOCATION_FAILED,
    iBase_NOT_SUPPORTED,
    iBase_FAILURE,
    iBase_ErrorType_MAX = iBase_FAILURE
        /**< facilitates iteration over all values */
  };

/***************************************************************************//**
 * \details
 * Many of the functions in iMesh can return arrays of tuples; that is, arrays
 * of multi-valued type. For example, the function iMesh_getVtxArrCoords,
 * returns an array of xyz coordinate 3-tuples (or, perhaps for geometrically
 * 2D meshes, xy 2-tuples). In these situations, there are multiple ways the
 * data can be organized in memory. For example, it could be stored xyz,xyz,xyz
 * or xxx...,yyy...,zzz.... These two different storage orders are referred
 * to as INTERLEAVED and BLOCKED, respectively. For some functions in iMesh,
 * the storage order is explicitly specified as an argument to the function.
 * For other functions, the storage order is not explicitly specified. And,
 * in these cases, it shall always be implicitly assumed to be INTERLEAVED.
 * This fact will be mentioned in the documentation for each specific function
 * where it applies. For example, in case of iMesh_getEntArrAdj, the returned
 * array of adjacent entities is multi-valued in that it stores for each
 * entity queried, all its adjacent entities. Such an array will be stored
 * INTERLEAVED with all adjacent entities for the first entity in the query
 * followed by all adjacent entities for the second entity in the query and
 * so forth.
 ******************************************************************************/
enum iBase_StorageOrder {
    iBase_StorageOrder_MIN = 0,
        /**< facilitates iteration over all values */
    iBase_BLOCKED = iBase_StorageOrder_MIN,
        /**< xxx...yyy...zzz... */
    iBase_INTERLEAVED,
        /**< xyzxyzxyz... */
    iBase_StorageOrder_MAX = iBase_INTERLEAVED
        /**< facilitates iteration over all values */
};

enum iBase_TagValueType {
    iBase_TagValueType_MIN = 0,
        /**< facilitates iteration over all values */
    iBase_BYTES = iBase_TagValueType_MIN,
        /**< An opaque sequence of bytes, size always measured in bytes */
    iBase_INTEGER,
        /**< A value of type \c int */
    iBase_DOUBLE,
        /**< A value of type \c double */
    iBase_ENTITY_HANDLE,
        /**< A value of type \c iBase_EntityHandle */
    iBase_ENTITY_SET_HANDLE,
        /**< A value of type \c iBase_EntitySetHandle */
    iBase_TagValueType_MAX = iBase_ENTITY_SET_HANDLE
        /**< facilitates iteration over all values */
};

/***************************************************************************//**
 * \page ibase iBase: ITAPS Base Interface
 ******************************************************************************/

/***************************************************************************//**
 * \defgroup iBase iBase
 ******************************************************************************/

/***************************************************************************//**
 * \defgroup VersionNumbers Version Numbers
 * \ingroup iBase
 ******************************************************************************/

/***************************************************************************//**
 * \defgroup ErrorHandling Error Handling
 * \ingroup iBase
 ******************************************************************************/

/***************************************************************************//**
 * \defgroup Datatypes Datatypes
 * \ingroup iBase
 ******************************************************************************/

/***************************************************************************//**
 * \mainpage The ITAPS Interfaces
 *
 * \subpage ibase
 *
 * \subpage imesh
 *
 * \subpage imeshp
 * 
 * \subpage igeom
 *
 * \subpage error
 *
 * \subpage trio
 *
 * \subpage strlen
 *
 * \subpage options
 *
 * \subpage numhops
 *
 * \page error Error Handling
 *
 * With few exceptions, every iMesh function includes an output argument,
 * 'int *err', which returns an error code indicating if the function call
 * may have failed. If the value returned for the 'err' argument is NOT
 * iBase_SUCCESS, the caller should NOT attempt to interpret (read the
 * values in) any of the other return arguments of the call. While some
 * implementations may actually return valid/useful results in other
 * return arguments of a call that has failed, there is no guarentee that
 * ALL implementations will do similarly and so depending on such behavior
 * is neither portable nor safe. This is true even if the returned values
 * are different from the values of the arguments before the call was
 * made.
 *
 * \page trio Array pointer, allocated and occupied sizes argument trio
 *
 * Many of the functions in iMesh have arguments corresponding to lists of 
 * objects.  In-type arguments for lists consist of a pointer to an array and
 * a list size.  Lists returned from functions are passed in three arguments,
 * a pointer to the array representing the list, and pointers to the
 * allocated and occupied lengths of the array.  These three arguments are 
 * inout-type arguments, because they can be allocated by the application and
 * passed into the interface to hold the results of the function.  Lists
 * which are pre-allocated must be large enough to hold the results of the
 * function; if this is not the case, an error is generated.  Otherwise, the
 * occupied size is changed to the size output from the function.  If a list
 * argument is unallocated (the list pointer points to a NULL value) or if
 * the incoming value of the allocated size is zero, the list storage will be
 * allocated by the implementation.
 *
 * IN ALL CASES, MEMORY ALLOCATED BY ITAPS INTERFACE IMPLEMENTATIONS IS DONE
 * USING THE C MALLOC FUNCTION, AND MUST BE DE-ALLOCATED USING THE C FREE
 * FUNCTION.
 *
 * \page strlen String Length Arguments
 *
 * Many of the functions in iMesh involve passing a string and also the length
 * of that string. How is the null character is handled?
 * For users of the iMesh interface calling iMesh functions, it is optional
 * as to whether or not to include the null character in computing the length
 * of the string. So, for example, calling iMesh from a C program, users could
 * pass strlen(my_string) or strlen(my_string)+1 as the length of the string.
 *
 * <em>Note to implementors</em>: However, it should be noted that the situation
 * is different for implementers of the iMesh interface. In implementing an
 * iMesh interface function, there can be no assumption that the string is
 * indeed null terminated. The length argument the caller passes in may or may
 * NOT include the null character and implementations must be coded to
 * accommodate this. This requirement is primarily due to differences in how
 * Fortran and C/C++ handle passing of strings as function arguments.
 *
 * \page numhops Indirection in Set-Inclusion and Parent-Child structures
 *
 * Various functions to query entities, entity sets and parent or child sets 
 * as well as the numbers of these involve a num_hops argument. If the set
 * upon which the query is originated is the root set, the num_hops argument
 * is irrelevant and is ignored by the implementation. Otherwise, the num_hops
 * argument represents the maximum number of levels of indirection employed in
 * satisfying the query not including the originating set. For example, using
 * value for num_hops of 0 (zero) in iMesh_getEntSets will return all the 
 * entity sets that are immediately contained in a given set. Likewise, a
 * value for num_hops of 1 (one) will return all entity sets that are 
 * immediately contained in the given set plus all entity sets that
 * are contained in those immediately contained sets (e.g. one level of
 * indirection). Using a value of -1 for num_hops will return results for
 * all possible levels of indirection. In other words, using a value of
 * -1 for num_hops is equivalent to setting the maximum number of levels
 * of indirection to infinity.
 *
 * \page options Option Strings
 *
 * A few of the functions in iMesh support arbitrary options passed as a
 * character string, called an 'Option String'. The format of and handling
 * of an Option String is as follows...
 *
 * 1. Option Strings are INsensitive to case.
 *
 * 2. Each option in an Option String is pre-pended with the implementation
 * name followed by a special character called the separator character.
 *
 * 3. The separator is a colon, ':'.
 *
 * 4. Multiple options existing in a single Option String are separated by a
 * special character called the delimiter character.
 *
 * 5. The delimiter character is a space, ' '.
 *
 * 6. The effect of multiple options in a single Option String is 
 * INsensitive to order of occurrence in the string.
 *
 * 7. By default, implementations silently ignore any options that
 * do not match on the implementation name part (everything before
 * the separator character). This way, a caller may included options
 * in a single string intended for multiple different implementations.
 *
 * 8. Implementations may (or may not) warn or error for option strings
 * that match on implementation name part but are found to be in error
 * for other reasons the implementation decides.
 *
 * 9. Whenever either the separator character, ':', or delimiter character,
 * ' ', need to appear in an option, they must be escaped with the
 * backslash character, '\'.
 *
 * For example, consider the Options String
 *
 *     "grummp:silant FMDB:TwoPhaseIO moab:mpiio_hints\ foo\:bar"
 *
 * In the above example, the space serves as the delimiter character
 * between multiple options in the string. The colon serves as the
 * implementation-name/option separator character. Because options are
 * required to be insensitive to case, the caller is free to use case as a
 * word separator as in 'TwoPhaseIO' and even in the implementation name,
 * as in 'FMDB:', although 'fmdb:twophaseio' and 'fmdb:TWOPHASEIO' would
 * all have the same effect. In the moab option, both the separator
 * character and delimiter character appear in the option and so are
 * pre-pended (e.g. escaped) with the backslash character.
 
 * GRUMMP will silently ignore the FMDB: and moab: options because they do
 * NOT match on the implementation name part. However, GRUMMP may
 * optionally error out, or warn or silently ignore 'grummp:silant' (it was
 * supposed to be spelled 'silent') as an invalid option.
 *
 * Note that iMesh itself currently does not define any options. In order
 * to discover options a given implementation defines, users are directed
 * to the developers of the respective implementations.
 ******************************************************************************/

#ifdef __cplusplus
}
#endif

#endif /* #ifndef _ITAPS_iBase */

/* iGeom interface */
#ifndef _ITAPS_iGeom
#define _ITAPS_iGeom

  /** \mainpage The ITAPS Geometry Interface iGeom
   *
   * The ITAPS Geometry Interface iGeom provides a common interface for
   * accessing geometry and data associated with a mesh.  Applications written
   * to use this interface can use a variety of implementations, choosing
   * the one that best meets its needs.  They can also use tools written
   * to this interface.
   *
   * \section ITAPS Data Model
   *
   * The ITAPS interfaces use a data model composed of four basic data types:\n
   * \em Entity: basic topological entities in a model, e.g. vertices, 
   * edges, faces, regions. \n
   * \em Entity \em Set: arbitrary grouping of other entities and sets. 
   * Entity sets also support parent/child relations with other sets which
   * are distinct from entities contained in those sets.  Parent/child links
   * can be used to embed graph relationships between sets, e.g. to 
   * represent topological relationships between the sets. \n
   * \em Interface: the object with which model is associated and on which
   * functions in iGeom are called. \n
   * \em Tag: application data associated with objects of any of the other 
   * data types.  Each tag has a designated name, size, and data type.
   *
   * \section JTAPS Entity Type
   * Each entity has a specific Entity Type.  The Entity 
   * Type is one of VERTEX, EDGE, FACE, and REGION, and is synonymous with
   * the topological dimension of the entity.  Entity Type is an enumerated
   * type in the iBase_EntityType enumeration.
   *
   * \section KTAPS Entity-, Array-, and Iterator-Based Access
   *
   * The iGeom interface provides functions for accessing entities
   * individually, as arrays of entities, or using iterators.  These access
   * methods have different memory versus execution time tradeoffs, 
   * depending on the implementation.
   *
   * \section LTAPS Lists Passed Through Interface
   *
   * Many of the functions in iGeom have arguments corresponding to lists of 
   * objects.  In-type arguments for lists consist of a pointer to an array and
   * a list size.  Lists returned from functions are passed in three arguments,
   * a pointer to the array representing the list, and pointers to the
   * allocated and occupied lengths of the array.  These three arguments are 
   * inout-type arguments, because they can be allocated by the application and
   * passed into the interface to hold the results of the function.  Lists
   * which are pre-allocated must be large enough to hold the results of the
   * function; if this is not the case, an error is generated.  Otherwise, the
   * occupied size is changed to the size output from the function.  If a list
   * argument is unallocated (the list pointer points to a NULL value) or if
   * the incoming value of the allocated size is zero, the list storage will be
   * allocated by the implementation.  IN ALL CASES, MEMORY ALLOCATED BY ITAPS
   * INTERFACE IMPLEMENTATIONS IS DONE USING THE C MALLOC FUNCTION, AND CAN BE
   * DE-ALLOCATED USING THE C FREE FUNCTION.
   *
   */

#include "iGeom_protos.h"
#include "CGMIGeomConfigure.h"

#ifdef __cplusplus
extern "C" {
#endif

    /**\brief  Type used to store iGeom interface handle
     *
     * Type used to store iGeom interface handle
     */
  typedef struct iGeom_Instance_Private* iGeom_Instance;

    /**\brief  Get a description of the error returned from the last iGeom call
     *
     * Get a description of the error returned from the last iGeom function
     * \param instance iGeom instance handle
     * \param descr Pointer to a character string to be filled with a
     *        description of the error from the last iGeom function
     * \param descr_len Length of the character string pointed to by descr
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getDescription( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                             char* descr,
                             int descr_len );

    /**\brief  Get the error type returned from the last iGeom function
     *
     * Get the error type returned from the last iGeom function.  Value
     * returned is a member of the iBase_ErrorType enumeration.
     * \param instance iGeom instance handle
     * \param *error_type Error type returned from last iGeom function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getErrorType( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           /*out*/ int *error_type );

    /**\brief  Construct a new iGeom instance
     *
     * Construct a new iGeom instance, using implementation-specific options
     * \param options Pointer to implementation-specific options string
     * \param instance Pointer to iGeom instance handle returned from function
     * \param *err Pointer to error type returned from function
     * \param options_len Length of the character string pointed to by options
     */
  CGMA_IGEOM_EXPORT
  void iGeom_newGeom( char const* options,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                      iGeom_Instance* instance_out,
                      int* err,
                      int options_len );

    /**\brief  Destroy an iGeom instance
     *
     * Destroy an iGeom instance
     * \param instance iGeom instance to be destroyed
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_dtor( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                   int* err );


    /**\brief  Load a geom from a file
     *
     * Load a geom from a file.  If entity set is specified, loaded geom
     * is added to that set; specify zero if that is not desired.
     * \param instance iGeom instance handle
     * \param entity_set_handle Set to which loaded geom will be added, zero
     *        if not desired
     * \param name File name from which geom is to be loaded
     * \param options Pointer to implementation-specific options string
     * \param *err Pointer to error type returned from function
     * \param name_len Length of the file name character string
     * \param options_len Length of the options character string
     */
  CGMA_IGEOM_EXPORT
  void iGeom_load( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                   char const* name,
                   char const* options,
                   int* err,
                   int name_len,
                   int options_len );

    /**\brief  Save a geom to a file
     *
     * Save a geom to a file.  If entity set is specified, save only the
     * geom contained in that set.
     * \param instance iGeom instance handle
     * \param entity_set_handle Entity set being saved
     * \param name File name to which geom is to be saved
     * \param options Pointer to implementation-specific options string
     * \param *err Pointer to error type returned from function
     * \param name_len Length of the file name character string
     * \param options_len Length of the options character string
     */
  CGMA_IGEOM_EXPORT
  void iGeom_save( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                   char const* name,
                   char const* options,
                   int* err,
                   int name_len,
                   int options_len );

    /**\brief  Get handle of the root set for this instance
     *
     * Get handle of the root set for this instance.  All geom in
     * this instance can be accessed from this set.
     * \param instance iGeom instance handle
     * \param root_set Pointer to set handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getRootSet( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntitySetHandle* root_set,
                         int* err );

    /**\brief Get the bounding box of the entire model
     *
     * Get the bounding box of the entire model
     * \param instance iGeom instance handle
     * \param min_x Minimum coordinate of bounding box
     * \param min_y Minimum coordinate of bounding box
     * \param min_z Minimum coordinate of bounding box
     * \param max_x Maximum coordinate of bounding box
     * \param max_y Maximum coordinate of bounding box
     * \param max_z Maximum coordinate of bounding box
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getBoundBox( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          double* min_x,
                          double* min_y,
                          double* min_z,
                          double* max_x,
                          double* max_y,
                          double* max_z,
                          int* err );

    /**\brief  Get entities of specific type in set or instance
     *
     * Get entities of specific type in set or instance.  All entities are
     * requested by specifying iBase_ALL_TYPES.  Specified type must be a value
     * in the iBase_EntityType enumeration.
     * \param instance iGeom instance handle
     * \param entity_set_handle Entity set being queried
     * \param entity_type Type of entities being requested
     * \param entity_topology Topology of entities being requested
     * \param *entity_handles Pointer to array of entity handles returned 
     *        from function
     * \param *entity_handles_allocated Pointer to allocated size of 
     *        entity_handles array
     * \param *entity_handles_size Pointer to occupied size of entity_handles
     *        array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntities( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntitySetHandle set_handle,
                          int entity_type,
                          iBase_EntityHandle** entity_handles,
                          int* entity_handles_allococated,
                          int* entity_handles_size,
                          int* err );

    /**\brief  Get the number of entities with the specified type in the
     *         instance or set
     *
     * Get the number of entities with the specified type in the instance 
     * or set.  If entity set handle is zero, return information for instance,
     * otherwise for set.  Value of entity type must be from the
     * iBase_EntityType enumeration.  If iBase_ALL_TYPES is specified, total
     * number of entities (excluding entity sets) is returned.
     * \param instance iGeom instance handle
     * \param entity_set_handle Entity set being queried
     * \param entity_type Type of entity requested
     * \param num_type Pointer to number of entities, returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getNumOfType( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntitySetHandle set_handle,
                           int entity_type,
                           int* num_out,
                           int* err );

    /**\brief  Get the entity type for the specified entity
     *
     * Get the entity type for the specified entity.  Type returned is a value
     * in the iBase_EntityType enumeration.
     * \param instance iGeom instance handle
     * \param entity_handle entity handle being queried
     * \param *type Pointer to location at which to store the returned type
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntType( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityHandle entity_handle,
                         int* type,
                         int* err );

    /**\brief  Get the entity type for the specified entities
     *
     * Get the entity type for the specified entities.  Types returned are
     * values in the iBase_EntityType enumeration.
     * \param instance iGeom instance handle
     * \param entity_handles Array of entity handles being queried
     * \param entity_handles_size Number of entities in entity_handles array
     * \param *type Pointer to array of types returned from function
     * \param *type_allocated Pointer to allocated size of type array
     * \param *type_size Pointer to occupied size of type array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrType( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityHandle const* entity_handles,
                         int entity_handles_size,
                         int** type,
                         int* type_allocated,
                         int* type_size,
                         int* err );

    /**\brief  Get entities of specified type adjacent to an entity
     *
     * Get entities of specified type adjacent to an entity.  Specified type
     * must be value in the iBase_EntityType enumeration.
     * \param instance iGeom instance handle
     * \param entity_handle Entity handle being queried
     * \param entity_type_requested Type of adjacent entities requested
     * \param *adj_entity_handles Pointer to array of adjacent entities
     *        returned from function
     * \param *adj_entity_handles_allocated Pointer to allocated size of 
     *        adj_entity_handles array
     * \param *adj_entity_handles_size Pointer to occupied size of 
     *        adj_entity_handles array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntAdj( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntityHandle entity_handle,
                        int to_dimension,
                        iBase_EntityHandle** adj_entities,
                        int* adj_entities_allocated,
                        int* adj_entities_size,
                        int* err );

    /**\brief  Get entities of specified type adjacent to entities
     *
     * Get entities of specified type adjacent to entities.  Specified type
     * must be value in the iBase_EntityType enumeration.  \em offset(i) is
     * index of first entity in adjacentEntityHandles array adjacent to 
     * entity_handles[i].
     * \param instance iGeom instance handle
     * \param entity_handles Array of entity handles being queried
     * \param entity_handles_size Number of entities in entity_handles array
     * \param entity_type_requested Type of adjacent entities requested
     * \param *adjacentEntityHandles Pointer to array of adjacentEntityHandles 
     *        returned from function
     * \param *adjacentEntityHandles_allocated Pointer to allocated size of 
     *        adjacentEntityHandles array
     * \param *adj_entity_handles_size Pointer to occupied size of 
     *        adjacentEntityHandles array
     * \param *offset Pointer to array of offsets returned from function
     * \param *offset_allocated Pointer to allocated size of offset array
     * \param *offset_size Pointer to occupied size of offset array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrAdj( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntityHandle const* entity_handles,
                        int entity_handles_size,
                        int requested_entity_type,
                        iBase_EntityHandle** adj_entity_handles,
                        int* adj_entity_handles_allocated,
                        int* adj_entity_handles_size,
                        int** offset,
                        int* offset_allocated,
                        int* offset_size,
                        int* err );

    /**\brief  Get "2nd order" adjacencies to an entity
     *
     * Get "2nd order" adjacencies to an entity, that is, from an entity,
     * through other entities of a specified "bridge" dimension, to other
     * entities of another specified "to" dimension.
     * \param instance iGeom instance handle
     * \param entity_handle Entity from which adjacencies are requested
     * \param bridge_dimension Bridge dimension for 2nd order adjacencies
     * \param to_dimension Dimension of adjacent entities returned
     * \param adjacent_entities Adjacent entities
     * \param adjacent_entities_allocated Allocated size of returned array
     * \param adjacent_entities_size Occupied size of returned array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEnt2ndAdj( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle entity_handle,
                           int bridge_dimension,
                           int to_dimension,
                           iBase_EntityHandle** adjacent_entities,
                           int* adjacent_entities_allocated,
                           int* adjacent_entities_size,
                           int* err );

    /**\brief  Get "2nd order" adjacencies to an array of entities
     *
     * Get "2nd order" adjacencies to an array of entities, that is, from each
     * entity, through other entities of a specified "bridge" dimension, to
     * other entities of another specified "to" dimension.
     * \param instance iGeom instance handle
     * \param entity_handles Entities from which adjacencies are requested
     * \param entity_handles_size Number of entities whose adjacencies are
     *        requested
     * \param bridge_dimension Bridge dimension for 2nd order adjacencies
     * \param to_dimension Dimension of adjacent entities returned
     * \param adj_entity_handles Adjacent entities
     * \param adj_entity_handles_allocated Allocated size of returned array
     * \param adj_entity_handles_size Occupied size of returned array
     * \param offset Offset[i] is offset into adj_entity_handles of 2nd order 
     *        adjacencies of ith entity in entity_handles
     * \param offset_allocated Allocated size of offset array
     * \param offset_size Occupied size of offset array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArr2ndAdj( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle const* entity_handles,
                           int entity_handles_size,
                           int order_adjacent_key,
                           int requested_entity_type,
                           iBase_EntityHandle** adj_entity_handles,
                           int* adj_entity_handles_allocated,
                           int* adj_entity_handles_size,
                           int** offset,
                           int* offset_allocated,
                           int* offset_size,
                           int* err );

    /**\brief  Return whether two entities are adjacent
     *
     * Return whether two entities are adjacent.
     * \param instance iGeom instance handle
     * \param entity_handle1 First entity queried
     * \param entity_handle2 Second entity queried
     * \param are_adjacent If returned non-zero, entities are adjacent,
     *        otherwise they are not
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isEntAdj( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                       iBase_EntityHandle entity_handle1,
                       iBase_EntityHandle entity_handle2,
                       int* are_adjacent,
                       int* err );

    /**\brief  Return whether entity pairs are adjacent
     *
     * Return whether entity pairs are adjacent, i.e. if entity_handles_1[i] is
     * adjacent to entity_handles_2[i].  This function requires
     * entity_handles_1_size and entity_handles_2_size to be equal.
     * \param instance iGeom instance handle
     * \param entity_handles_1 First array of entities
     * \param entity_handles_1_size Number of entities in first array
     * \param entity_handles_2 Second array of entities
     * \param entity_handles_2_size Number of entities in second array
     * \param is_adjacent_info Array of flags returned from function
     * \param is_adjacent_info_allocated Allocated size of flags array
     * \param is_adjacent_info_size Occupied size of flags array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isArrAdj( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                       iBase_EntityHandle const* entity_handles_1,
                       int entity_handles_1_size,
                       iBase_EntityHandle const* entity_handles_2,
                       int entity_handles_2_size,
                       int** is_adjacent_info,
                       int* is_adjacent_info_allocated,
                       int* is_adjacent_info_size,
                       int* err );

    /**\brief  Return the topology level of the geometry
     *
     * Return the topology level of the geometry as an integer, where 0 = basic
     * entities only, 1 = manifold entities, 2 = non-manifold entities.
     * \param instance iGeom instance handle
     * \param topo_level_out The topology level
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getTopoLevel( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           int* topo_level_out,
                           int* err );

    /**\brief  Get closest point to an entity
     *
     * Get closest point to a specified position on an entity
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param near_x Coordinates of starting point
     * \param near_y Coordinates of starting point
     * \param near_z Coordinates of starting point
     * \param on_x Closest point on entity
     * \param on_y Closest point on entity
     * \param on_z Closest point on entity
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntClosestPt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle entity_handle,
                              double near_x, 
                              double near_y,
                              double near_z,
                              double* on_x,
                              double* on_y,
                              double* on_z,
                              int* err );

    /**\brief  Get closest point for an array of entities and points
     * For surfaces, closest point could be on the void space inside it.
     * Get closest point for an array of entities and points.  If either the
     * number of entities or number of coordinate triples is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of input points
     * \param near_coordinates Coordinates of starting point(s)
     * \param near_coordinates_size Number of values in near_coordinates array
     * \param on_coordinates Coordinates of closest points
     * \param on_coordinates_allocated Allocated size of closest point array
     * \param on_coordinates_size Occupied size of closest point array
     * \param *err Pointer to error type returned from function
     */

  CGMA_IGEOM_EXPORT
  void iGeom_getEntClosestPtTrimmed( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                                     iBase_EntityHandle entity_handle,
                                     double near_x,
                                     double near_y,
                                     double near_z,
                                     double* on_x,
                                     double* on_y,
                                     double* on_z,
                                     int* err );

    /**\brief  Get closest point for an array of entities and points
     * For surfaces, it made sure the closest point in on surface.
     * Get closest point for an array of entities and points.  If either the
     * number of entities or number of coordinate triples is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of input points
     * \param near_coordinates Coordinates of starting point(s)
     * \param near_coordinates_size Number of values in near_coordinates array
     * \param on_coordinates Coordinates of closest points
     * \param on_coordinates_allocated Allocated size of closest point array
     * \param on_coordinates_size Occupied size of closest point array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrClosestPt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle const* entity_handles,
                              int entity_handles_size,
                              int storage_order,
                              double const* near_coordinates,
                              int near_coordinates_size,
                              double** on_coordinates,
                              int* on_coordinates_allocated,
                              int* on_coordinates_size,
                              int* err );

    /**\brief  Get the normal vector on an entity at the given position
     * Get the normal vector on an entity at the given position.
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param x Coordinates of starting point
     * \param y Coordinates of starting point
     * \param z Coordinates of starting point
     * \param nrml_i Normal vector at starting point
     * \param nrml_j Normal vector at starting point
     * \param nrml_k Normal vector at starting point
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntNrmlXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle entity_handle,
                            double x,
                            double y,
                            double z,
                            double* nrml_i,
                            double* nrml_j,
                            double* nrml_k,
                            int* err );

    /**\brief  Get the normal vector on an entity(ies) at given position(s)
     *
     * Get the normal vector on an entity(ies) at given position(s).  If either
     * the number of entities or number of coordinate triples is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of coordinates
     * \param coordinates Starting coordinates
     * \param coordinates_size Number of values in coordinates array
     * \param normals Normal coordinates
     * \param normals_allocated Allocated size of normals array
     * \param normals_size Occupied size of normals array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrNrmlXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double const* coordinates,
                            int coordinates_size,
                            double** normals,
                            int* normals_allocated,
                            int* normals_size,
                            int* err );

    /**\brief  Get the normal vector AND closest point on an entity at given
     *         position
     *
     * Get the normal vector AND closest point on an entity at a given position.
     * \param entity_handle Entity being queried
     * \param instance iGeom instance handle
     * \param x Starting coordinates
     * \param y Starting coordinates
     * \param z Starting coordinates
     * \param pt_x Closest point
     * \param pt_y Closest point
     * \param pt_z Closest point
     * \param nrml_i Normal at closest point
     * \param nrml_j Normal at closest point
     * \param nrml_k Normal at closest point
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntNrmlPlXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle entity_handle,
                              double x,
                              double y,
                              double z,
                              double* pt_x,
                              double* pt_y,
                              double* pt_z,
                              double* nrml_i,
                              double* nrml_j,
                              double* nrml_k,
                              int* err );

    /**\brief Get the normal vector AND closest point on an entity(ies) at
     *        given position(s)
     *
     * Get the normal vector AND closest point on an entity(ies) at given
     * position(s).  If either the number of entities or number of coordinate
     * triples is unity, then all points or entities are queried for that entity
     * or point, respectively, otherwise each point corresponds to each entity.
     * storage_order should be a value in the iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entity(ies) being queried
     * \param storage_order Storage order in near_coordinates array
     * \param near_coordinates Starting coordinates
     * \param near_coordinates_size Number of values in near_coordinates array
     * \param on_coordinates Closest point array
     * \param on_coordinates_allocated Allocated size of closest point array
     * \param on_coordinates_size Occupied size of closest point array
     * \param normals Normal array
     * \param normals_allocated Allocated size of normal array
     * \param normals_size Occupied size of normal array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrNrmlPlXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle const* entity_handles,
                              int entity_handles_size,
                              int storage_order,
                              double const* near_coordinates,
                              int near_coordinates_size,
                              double** on_coordinates,
                              int* on_coordinates_allocated,
                              int* on_coordinates_size,
                              double** normals,
                              int* normals_allocated,
                              int* normals_size,
                              int* err );

    /**\brief  Get the tangent vector on an entity at given position
     *
     * Get the tangent vector on an entity at a given position.
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param x Starting coordinates
     * \param y Starting coordinates
     * \param z Starting coordinates
     * \param tgnt_i Tangent at closest point
     * \param tgnt_j Tangent at closest point
     * \param tgnt_k Tangent at closest point
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntTgntXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle entity_handle,
                            double x,
                            double y,
                            double z,
                            double* tgnt_i,
                            double* tgnt_j,
                            double* tgnt_k,
                            int* err );

    /**\brief  Get the tangent vector on an entity(ies) at given position(s)
     *
     * Get the tangent vector on an entity(ies) at given position(s).  If either
     * the number of entities or number of coordinate triples is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum
     * \param instance iGeom instance handle
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of coordinates
     * \param coordinates Starting coordinates
     * \param coordinates_size Number of values in coordinates array
     * \param tangents Tangent coordinates
     * \param tangents_allocated Allocated size of tangents array
     * \param tangents_size Occupied size of tangents array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrTgntXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double const* coordinates,
                            int coordinates_size,
                            double** tangents,
                            int* tangents_allocated,
                            int* tangents_size,
                            int* err );

    /**\brief  Get the two principle curvature vectors for a face at a point
     *
     * Get the two principle curvature vectors for a face at a point.
     * Magnitudes of vectors are curvature, directions are directions of
     * principal curvatures.
     * \param instance iGeom instance handle
     * \param face_handle Face being queried
     * \param x Position being queried
     * \param y Position being queried
     * \param z Position being queried
     * \param cvtr1_i Maximum curvature vector
     * \param cvtr1_j Maximum curvature vector
     * \param cvtr1_k Maximum curvature vector
     * \param cvtr2_i Minimum curvature vector
     * \param cvtr2_j Minimum curvature vector
     * \param cvtr2_k Minimum curvature vector
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getFcCvtrXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle face_handle,
                           double x,
                           double y,
                           double z,
                           double* cvtr1_i,
                           double* cvtr1_j,
                           double* cvtr1_k,
                           double* cvtr2_i,
                           double* cvtr2_j,
                           double* cvtr2_k,
                           int* err );

    /**\brief  Get the principle curvature vector for an edge at a point
     *
     * Get the principle curvature vector for an edge at a point.  Magnitude of
     * vector is the curvature, direction is direction of principal curvature.
     * \param instance iGeom instance handle
     * \param edge_handle Edge being queried
     * \param x Position being queried
     * \param y Position being queried
     * \param z Position being queried
     * \param cvtr_i Maximum curvature vector
     * \param cvtr_j Maximum curvature vector
     * \param cvtr_k Maximum curvature vector
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEgCvtrXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle edge_handle,
                           double x,
                           double y,
                           double z,
                           double* cvtr_i,
                           double* cvtr_j,
                           double* cvtr_k,
                           int* err );

    /**\brief  Get the curvature(s) on an entity(ies) at given position(s)
     *
     * Get the curvature(s) on an entity(ies) at given position(s).  If either
     * the number of entities or number of coordinate triples is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param entity_handles Entity(ies) being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of coordinates
     * \param coords Starting coordinates
     * \param coords_size Number of values in coordinates array
     * \param cvtr_1 First principal curvatures
     * \param cvtr_1_allocated Allocated size of first curvature array
     * \param cvtr_1_size Occupied size of first curvature array
     * \param cvtr_2 Second principal curvatures
     * \param cvtr_2_allocated Allocated size of second curvature array
     * \param cvtr_2_size Occupied size of second curvature array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntArrCvtrXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                               iBase_EntityHandle const* entity_handles,
                               int entity_handles_size,
                               int storage_order,
                               double const* coords,
                               int coords_size,
                               double** cvtr_1,
                               int* cvtr_1_allocated,
                               int* cvtr_1_size,
                               double** cvtr_2,
                               int* cvtr_2_allocated,
                               int* cvtr_2_size,
                               int* err );

    /**\brief  Get closest point, tangent, and curvature of edge
     *
     * Get closest point, tangent, and curvature of edge.
     * \param instance iGeom instance handle
     * \param edge_handle Edge being queried
     * \param x Point at which entity is being queried
     * \param y Point at which entity is being queried
     * \param z Point at which entity is being queried
     * \param on_x Closest point at point being queried
     * \param on_y Closest point at point being queried
     * \param on_z Closest point at point being queried
     * \param tgnt_i Tangent at point being queried
     * \param tgnt_j Tangent at point being queried
     * \param tgnt_k Tangent at point being queried
     * \param cvtr_i Curvature at point being queried
     * \param cvtr_j Curvature at point being queried
     * \param cvtr_k Curvature at point being queried
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEgEvalXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle edge_handle,
                           double x,
                           double y,
                           double z,
                           double* on_x,
                           double* on_y,
                           double* on_z,
                           double* tgnt_i,
                           double* tgnt_j,
                           double* tgnt_k,
                           double* cvtr_i,
                           double* cvtr_j,
                           double* cvtr_k,
                           int* err );

    /**\brief  Get closest point, tangent, and curvature of face
     *
     * Get closest point, tangent, and curvature of face.  If any of input
     * coordinate pointers are NULL, that value is not returned.
     * \param instance iGeom instance handle
     * \param face_handle Face being queried
     * \param x Point at which entity is being queried
     * \param y Point at which entity is being queried
     * \param z Point at which entity is being queried
     * \param on_x Closest point at point being queried
     * \param on_y Closest point at point being queried
     * \param on_z Closest point at point being queried
     * \param nrml_i Normal at point being queried
     * \param nrml_j Normal at point being queried
     * \param nrml_k Normal at point being queried
     * \param cvtr1_i First principal curvature at point being queried
     * \param cvtr1_j First principal curvature at point being queried
     * \param cvtr1_k First principal curvature at point being queried
     * \param cvtr2_i Second principal curvature at point being queried
     * \param cvtr2_j Second principal curvature at point being queried
     * \param cvtr2_k Second principal curvature at point being queried
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getFcEvalXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle face_handle,
                           double x,
                           double y,
                           double z,
                           double* on_x,
                           double* on_y,
                           double* on_z,
                           double* nrml_i,
                           double* nrml_j,
                           double* nrml_k,
                           double* cvtr1_i,
                           double* cvtr1_j,
                           double* cvtr1_k,
                           double* cvtr2_i,
                           double* cvtr2_j,
                           double* cvtr2_k,
                           int* err );

    /**\brief  Get the closest point(s), tangent(s), and curvature(s) on an
     *         entity(ies) at given position(s)
     *
     * Get the closest point(s), tangent(s), and curvature(s) on an entity(ies)
     * at given position(s).  If either the number of entities or number of
     * coordinate triples is unity, then all points or entities are queried for
     * that entity or point, respectively, otherwise each point corresponds to
     * each entity.  storage_order should be a value in the iBase_StorageOrder
     * enum.
     * \param instance iGeom instance handle
     * \param edge_handles Edge(s) being queried
     * \param edge_handles_size Number of edges being queried
     * \param storage_order Storage order of coordinates
     * \param coords Starting coordinates
     * \param coords_size Number of values in coordinates array
     * \param on_coords Closest point array
     * \param on_coords_allocated Allocated size of closest point array
     * \param on_coords_size Occupied size of closest point array
     * \param tangent Tangent array
     * \param tangent_allocated Allocated size of tangent array
     * \param tangent_size Occupied size of tangent array
     * \param cvtr First principal curvatures
     * \param cvtr_allocated Allocated size of first curvature array
     * \param cvtr_size Occupied size of first curvature array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrEgEvalXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle const* edge_handles,
                              int edge_handles_size,
                              int storage_order,
                              double const* coords,
                              int coords_size,
                              double** on_coords,
                              int* on_coords_allocated,
                              int* on_coords_size,
                              double** tangent,
                              int* tangent_allocated,
                              int* tangent_size,
                              double** cvtr,
                              int* cvtr_allocated,
                              int* cvtr_size,
                              int* err );

    /**\brief  Get the closest point(s), tangent(s), and curvature(s) on an
     *         entity(ies) at given position(s)
     *
     * Get the closest point(s), tangent(s), and curvature(s) on an entity(ies)
     * at given position(s).  If either the number of entities or number of
     * coordinate triples is unity, then all points or entities are queried for
     * that entity or point, respectively, otherwise each point corresponds to
     * each entity.  storage_order should be a value in the iBase_StorageOrder
     * enum.
     * \param instance iGeom instance handle
     * \param edge_handles Edge(s) being queried
     * \param edge_handles_size Number of edges being queried
     * \param storage_order Storage order of coordinates
     * \param coords Starting coordinates
     * \param coords_size Number of values in coordinates array
     * \param on_coords Closest point array
     * \param on_coords_allocated Allocated size of closest point array
     * \param on_coords_size Occupied size of closest point array
     * \param normal Normal array
     * \param normal_allocated Allocated size of normal array
     * \param normal_size Occupied size of normal array
     * \param cvtr_1 First principal curvatures
     * \param cvtr_1_allocated Allocated size of first curvature array
     * \param cvtr_1_size Occupied size of first curvature array
     * \param cvtr_2 Second principal curvatures
     * \param cvtr_2_allocated Allocated size of second curvature array
     * \param cvtr_2_size Occupied size of second curvature array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrFcEvalXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle const* face_handles,
                              int face_handles_size,
                              int storage_order,
                              double const* coords,
                              int coords_size,
                              double** on_coords,
                              int* on_coords_allocated,
                              int* on_coords_size,
                              double** normal,
                              int* normal_allocated,
                              int* normal_size,
                              double** cvtr1,
                              int* cvtr1_allocated,
                              int* cvtr1_size,
                              double** cvtr2,
                              int* cvtr2_allocated,
                              int* cvtr2_size,
                              int* err );

    /**\brief  Get the bounding box of the specified entity
     *
     * Get the bounding box of the specified entity
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param min_x Minimum coordinate of bounding box 
     * \param min_y Minimum coordinate of bounding box 
     * \param min_z Minimum coordinate of bounding box 
     * \param max_x Maximum coordinate of bounding box 
     * \param max_y Maximum coordinate of bounding box 
     * \param max_z Maximum coordinate of bounding box 
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntBoundBox( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                             iBase_EntityHandle entity_handle,
                             double* min_x,
                             double* min_y,
                             double* min_z,
                             double* max_x,
                             double* max_y,
                             double* max_z,
                             int* err );

    /**\brief  Get the bounding box of the specified entities
     *
     * Get the bounding box of the specified entities.  Storage order passed in
     * should be a member of iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param entity_handles Entity handles being queried
     * \param enttiy_handles_size Number of entities being queried
     * \param storage_order Storage order of coordinates passed back
     * \param min_corner Minimum coordinates of bounding boxes
     * \param min_corner_allocated Allocated size of minimum coordinates array
     * \param min_corner_size Occupied size of minimum coordinates array
     * \param max_corner Maximum coordinates of bounding boxes
     * \param max_corner_allocated Allocated size of maximum coordinates array
     * \param max_corner_size Occupied size of maximum coordinates array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrBoundBox( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                             iBase_EntityHandle const* entity_handles,
                             int entity_handles_size,
                             int storage_order,
                             double** min_corner,
                             int* min_corner_allocated,
                             int* min_corner_size,
                             double** max_corner,
                             int* max_corner_allocated,
                             int* max_corner_size,
                             int* err );

    /**\brief  Get coordinates of specified vertex
     *
     * Get coordinates of specified vertex.
     * \param instance iGeom instance handle
     * \param vertex_handle Geom vertex being queried
     * \param *x Pointer to x coordinate returned from function
     * \param *y Pointer to y coordinate returned from function
     * \param *z Pointer to z coordinate returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getVtxCoord( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntityHandle vertex_handle,
                          double* x,
                          double* y,
                          double* z,
                          int* err );

    /**\brief  Get coordinates of specified vertices
     *
     * Get coordinates of specified vertices.  If storage order is passed in
     * with a value other than iBase_UNDETERMINED, coordinates are returned
     * in the specified storage order, otherwise storage order is that native
     * to the implementation.  Storage order of returned coordinates is also
     * returned.
     * \param instance iGeom instance handle
     * \param vertex_handles Array of geom vertex handles whose coordinates are
     *        being requested
     * \param vertex_handles_size Number of vertices in vertex_handles array
     * \param storage_order Storage order requested for coordinate data
     * \param *coords Pointer to array of coordinates returned from function
     * \param *coords_allocated Pointer to allocated size of coords array
     * \param *coords_size Pointer to occupied size of coords array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getVtxArrCoords( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle const* entity_handles,
                              int entity_handles_size,
                              int storage_order,
                              double** coordinates,
                              int* coordinates_allocated,
                              int* coordinates_size,
                              int* err );

    /**\brief  Intersect a ray with the model
     *
     * Intersect a ray with the model.  Storage orders passed in should be a
     * member of the iBase_StorageOrder enumeration.
     * \param instance iGeom instance handle
     * \param x Point from which ray is fired
     * \param y Point from which ray is fired
     * \param z Point from which ray is fired
     * \param dir_x Direction in which ray is fired
     * \param dir_y Direction in which ray is fired
     * \param dir_z Direction in which ray is fired
     * \param intersect_entity_handles Entities intersected by ray
     * \param intersect_entity_handles_allocated Allocated size of
     *        intersections array
     * \param intersect_entity_hangles_size Occupied size of intersections array
     * \param storage_order Storage order of coordinates passed back
     * \param intersect_coords Coordinates of intersections
     * \param intersect_coords_allocated Allocated size of coordinates array
     * \param intersect_coords_size Occupied size of coordinates array
     * \param param_coords Distances along ray of intersections
     * \param param_coords_allocated Allocated size of param_coords array
     * \param param_coords_size Occupied size of param_coords array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getPntRayIntsct( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              double x,
                              double y,
                              double z,
                              double dir_x,
                              double dir_y,
                              double dir_z,
                              iBase_EntityHandle** intersect_entity_handles,
                              int* intersect_entity_handles_allocated,
                              int* intersect_entity_hangles_size,
                              int storage_order,
                              double** intersect_coords,
                              int* intersect_coords_allocated,
                              int* intersect_coords_size,
                              double** param_coords,
                              int* param_coords_allocated,
                              int* param_coords_size,
                              int* err );

    /**\brief  Intersect an array of rays with the model
     *
     * Intersect an array of rays with the model.  Storage order passed in is
     * a member of the iBase_StorageOrder enumeration.
     * \param instance iGeom instance handle
     * \param storage_order Storage order of input coordinates
     * \param coords Points from which rays are fired
     * \param coords_size Number of points from which rays are fired
     * \param directions Directions in which rays are fired
     * \param directions_size Number of coordinates in directions array
     * \param intersect_entity_handles Entities intersected by ray
     * \param intersect_entity_handles_allocated Allocated size of intersections
     *        array
     * \param intersect_entity_hangles_size Occupied size of intersections array
     * \param offset Offset[i] is offset into intersect_entity_handles of ith
     *        ray
     * \param offset_allocated Allocated size of offset array
     * \param offset_size Occupied size of offset array
     * \param storage_order Storage order of coordinates passed back
     * \param intersect_coords Coordinates of intersections
     * \param intersect_coords_allocated Allocated size of coordinates array
     * \param intersect_coords_size Occupied size of coordinates array
     * \param param_coords Distances along ray of intersections
     * \param param_coords_allocated Allocated size of param_coords array
     * \param param_coords_size Occupied size of param_coords array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getPntArrRayIntsct( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                                 int storage_order,
                                 const double* coords,
                                 int coords_size,
                                 const double* directions,
                                 int directions_size,
                                 iBase_EntityHandle** intersect_entity_handles,
                                 int* intersect_entity_handles_allocated,
                                 int* intersect_entity_hangles_size,
                                 int** offset,
                                 int* offset_allocated,
                                 int* offset_size,
                                 double** intersect_coords,
                                 int* intersect_coords_allocated,
                                 int* intersect_coords_size,
                                 double** param_coords,
                                 int* param_coords_allocated,
                                 int* param_coords_size,
                                 int* err );

    /**\brief  Get the entity on which a point is located
     *
     * Get the entity on which a point is located
     * \param instance iGeom instance handle
     * \param x Point being queried
     * \param y Point being queried
     * \param z Point being queried
     * \param entity_handle Entity on which point is located
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getPntClsf( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         double x,
                         double y,
                         double z,
                         iBase_EntityHandle* entity_handle,
                         int* err );

    /**\brief  Get the entities on which points are located
     *
     * Get the entities on which points are located.  Storage orders should be
     * members of the iBase_StorageOrder enumeration.
     * \param instance iGeom instance handle
     * \param storage_order Storage order of coordinates in coords
     * \param coords Points being queried
     * \param coords_size Number of entries in coords array
     * \param entity_handles Entities on which points are located
     * \param entity_handles_allocated Allocated size of entity_handles array
     * \param entity_handles_size Occupied size of entity_handles array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getPntArrClsf( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            int storage_order,
                            double const* coords,
                            int coords_size,
                            iBase_EntityHandle** entity_handles,
                            int* entity_handles_allocated,
                            int* entity_handles_size,
                            int* err );

    /**\brief  Get the sense of a face with respect to a region
     *
     * Get the sense of a face with respect to a region.  Sense returned is -1,
     * 0, or 1, representing "reversed", "both", or "forward".  "both" sense
     * indicates that face bounds the region once with each sense.
     * \param instance iGeom instance handle
     * \param face Face being queried
     * \param region Region being queried
     * \param sense_out Sense of face with respect to region
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntNrmlSense( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle face,
                              iBase_EntityHandle region,
                              int* sense_out,
                              int* err );

    /**\brief  Get the senses of an array of faces with respect to an array of
     *         regions
     *
     * Get the senses of an array of faces with respect to an array of regions.
     * Sense returned is -1, 0, or 1, representing "reversed", "both", or
     * "forward".  "both" sense indicates that face bounds the region once with
     * each sense.
     * \param instance iGeom instance handle
     * \param face_handles Faces being queried
     * \param face_handles_size Size of face handles array
     * \param region_handles Regions being queried
     * \param region_handles_size Size of region handles array
     * \param sense Senses of faces with respect to regions
     * \param sense_allocated Allocated size of senses array
     * \param sense_size Occupied size of senses array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrNrmlSense( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle const* face_handles,
                              int face_handles_size,
                              iBase_EntityHandle const* region_handles,
                              int region_handles_size,
                              int** sense,
                              int* sense_allocated,
                              int* sense_size,
                              int* err );

    /**\brief  Get the sense of an edge with respect to a face
     *
     * Get the sense of an edge with respect to a face.  Sense returned is -1,
     * 0, or 1, representing "reversed", "both", or "forward".  "both" sense
     * indicates that edge bounds the face once with each sense.
     * \param instance iGeom instance handle
     * \param edge Edge being queried
     * \param face Face being queried
     * \param sense_out Sense of edge with respect to face
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEgFcSense( iGeom_Instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle edge,
                           iBase_EntityHandle face,
                           int* sense_out,
                           int* err );

    /**\brief  Get the senses of an array of edges with respect to an array of
     *         faces
     *
     * Get the senses of an array of edges with respect to an array of faces.
     * Sense returned is -1, 0, or 1, representing "reversed", "both", or
     * "forward".  "both" sense indicates that edge bounds the face once with
     * each sense.
     * \param instance iGeom instance handle
     * \param edge_handles Edges being queried
     * \param edge_handles_size Size of edge handles array
     * \param face_handles Faces being queried
     * \param face_handles_size Size of face handles array
     * \param sense Senses of faces with respect to regions
     * \param sense_allocated Allocated size of senses array
     * \param sense_size Occupied size of senses array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEgFcArrSense( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle const* edge_handles,
                              int edge_handles_size,
                              iBase_EntityHandle const* face_handles,
                              int face_handles_size,
                              int** sense,
                              int* sense_allocated,
                              int* sense_size,
                              int* err );

    /**\brief  Get the sense of a vertex pair with respect to an edge
     *
     * Get the sense of a vertex pair with respect to an edge.  Sense returned
     * is -1, 0, or 1, representing "reversed", "both", or "forward".  "both"
     * sense indicates that vertices are identical and that vertex bounds both
     * sides of the edge.
     * \param instance iGeom instance handle
     * \param edge Edge being queried
     * \param vertex1 First vertex being queried
     * \param vertex2 Second vertex being queried
     * \param sense_out Sense of vertex pair with respect to edge
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEgVtxSense( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle edge,
                            iBase_EntityHandle vertex1,
                            iBase_EntityHandle vertex2,
                            int* sense_out,
                            int* err );

    /**\brief  Get the senses of vertex pair with respect to a edges
     *
     * Get the senses of vertex pairs with respect to edges.  Sense returned is
     * -1, 0, or 1, representing "reversed", "both", or "forward".  "both" sense
     * indicates that both vertices in pair are identical and that vertex bounds
     * both sides of the edge.
     * \param instance iGeom instance handle
     * \param edge_handles Edges being queried
     * \param edge_handles_size Number of edges being queried
     * \param vertex_handles_1 First vertex being queried
     * \param vertex_handles_1_size Number of vertices in vertices array
     * \param vertex_handles_2 Second vertex being queried
     * \param vertex_handles_2_size Number of vertices in vertices array
     * \param sense Sense of vertex pair with respect to edge
     * \param sense_allocated Allocated size of sense array
     * \param sense_size Occupied size of sense array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEgVtxArrSense( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                               iBase_EntityHandle const* edge_handles,
                               int edge_handles_size,
                               iBase_EntityHandle const* vertex_handles_1,
                               int veretx_handles_1_size,
                               iBase_EntityHandle const* vertex_handles_2,
                               int vertex_handles_2_size,
                               int** sense,
                               int* sense_allocated,
                               int* sense_size,
                               int* err );

    /**\brief  Return the measure (length, area, or volume) of entities
     *
     * Return the measure (length, area, or volume) of entities
     * \param instance iGeom instance handle
     * \param entity_handles Array of entities being queried
     * \param entity_handles_size Number of entities in entity array
     * \param measures Measures of entities being queried
     * \param measures_allocated Allocated size of measures array
     * \param measures_size Occupied size of measures array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_measure( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                      iBase_EntityHandle const* entity_handles,
                      int entity_handles_size,
                      double** measures,
                      int* measures_allocated,
                      int* measures_size,
                      int* err );

    /**\brief  Get the geometric type of a face
     *
     * Get the geometric type of a face.  Specific types depend on
     * implementation.
     * \param instance iGeom instance handle
     * \param face_handle Face being queried
     * \param face_type Face type
     * \param face_type_length Length of face type string
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getFaceType( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntityHandle face_handle,
                          char* face_type,
                          int* err,
                          int* face_type_length);

    /**\brief  Return whether interface has information about parameterization
     *
     * Return whether an interface has information about parameterization (!=0)
     * or not (0)
     * \param instance iGeom instance handle
     * \param is_parametric If non-zero, interface has information about
     *        parameterization
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getParametric( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            int* is_parametric,
                            int* err );

    /**\brief  Return whether an entity has a parameterization
     *
     * Return whether an entity has a parameterization (=1) or not (=0)
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param is_parametric Entity has a parameterization (=1) or not (=0)
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isEntParametric( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle entity_handle,
                              int* parametric,
                              int* err );

    /**\brief  Return whether entities have parameterizations
     *
     * Return whether entities have parameterizations (=1) or not (=0)
     * \param instance iGeom instance handle
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param is_parametric entity_handles[i] has a parameterization (=1) or
     *        not (=0)
     * \param is_parametric_allocated Allocated size of is_parametric array
     * \param is_parametric_size Occupied size of is_parametric array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isArrParametric( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle const* entity_handles,
                              int entity_handles_size,
                              int** is_parametric,
                              int* is_parametric_allocated,
                              int* is_parametric_size,
                              int* err );

    /**\brief  Return coordinate position at specified parametric position on
     *         entity
     *
     * Return coordinate position at specified parametric position on entity.
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param u Parametric coordinate being queried
     * \param v Parametric coordinate being queried
     * \param x Spatial coordinate at parametric position being queried
     * \param y Spatial coordinate at parametric position being queried
     * \param z Spatial coordinate at parametric position being queried
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntUVtoXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle entity_handle,
                            double u,
                            double v,
                            double* x,
                            double* y,
                            double* z,
                            int* err );

    /**\brief  Return coordinate positions at specified parametric position(s)
     *         on entity(ies)
     *
     * Return coordinate positions at specified parametric position(s) on
     * entity(ies).  If either the number of entities or number of parametric
     * coordinate pairs is unity, then all points or entities are queried for
     * that entity or point, respectively, otherwise each point corresponds to
     * each entity.  storage_order should be a value in the iBase_StorageOrder
     * enum.
     * \param instance iGeom instance handle
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of uv coordinates input and xyz
     *        coordinate output
     * \param uv Coordinates being queried
     * \param uv_size Number of coordinates in array
     * \param coordinates Coordinates of parametric positions
     * \param coordinates_allocated Allocated size of coordinates array
     * \param coordinates_size Occupied size of coordinates array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrUVtoXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double const* uv,
                            int uv_size,
                            double** coordinates,
                            int* coordinates_allocated,
                            int* coordinates_size,
                            int* err );

    /**\brief  Return coordinate position at specified parametric position on
     *         entity
     *
     * Return coordinate position at specified parametric position on entity.
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param u Parametric coordinate being queried
     * \param x Spatial coordinate at parametric position being queried
     * \param y Spatial coordinate at parametric position being queried
     * \param z Spatial coordinate at parametric position being queried
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntUtoXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle entity_handle,
                           double u,
                           double* x, 
                           double* y,
                           double* z,
                           int* err );

    /**\brief  Return coordinate positions at specified parametric position(s)
     *         on entity(ies)
     *
     * Return coordinate positions at specified parametric position(s) on
     * entity(ies). If either the number of entities or number of parametric
     * coordinate pairs is unity, then all points or entities are queried for
     * that entity or point, respectively, otherwise each point corresponds to
     * each entity.  storage_order should be a value in the iBase_StorageOrder
     * enum.
     * \param instance iGeom instance handle
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of resulting coordinates
     * \param uv Coordinates being queried
     * \param uv_size Number of coordinates in array
     * \param coordinates Coordinates of parametric positions
     * \param coordinates_allocated Allocated size of coordinates array
     * \param coordinates_size Occupied size of coordinates array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrUtoXYZ( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle const* entity_handles,
                           int entity_handles_size,
                           double const* u,
                           int u_size,
                           int storage_order,
                           double** on_coords,
                           int* on_coords_allocated,
                           int* on_coords_size,
                           int* err );

    /**\brief  Return parametric position at specified spatial position on
     *         entity
     *
     * Return parametric position at specified spatial position on entity
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param x Spatial coordinate being queried
     * \param y Spatial coordinate being queried
     * \param z Spatial coordinate being queried
     * \param u Parametric coordinate at spatial position being queried
     * \param v Parametric coordinate at spatial position being queried
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntXYZtoUV( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle entity_handle,
                            double x,
                            double y,
                            double z,
                            double* u,
                            double* v, 
                            int* err );

    /**\brief  Return parametric position at specified spatial position on
     *         entity
     *
     * Return parametric position at specified spatial position on entity
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param x Spatial coordinate being queried
     * \param y Spatial coordinate being queried
     * \param z Spatial coordinate being queried
     * \param u Parametric coordinate at spatial position being queried
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntXYZtoU( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle entity_handle,
                           double x,
                           double y,
                           double z,
                           double* u,
                           int* err );

    /**\brief  Return parametric positions at specified spatial position(s) on
     *         entity(ies)
     * Return parametric positions at specified spatial position(s) on
     * entity(ies).  If either the number of entities or number of spatial
     * coordinate triples is unity, then all points or entities are queried for
     * that entity or point, respectively, otherwise each point corresponds to
     * each entity.  storage_order should be a value in the iBase_StorageOrder
     * enum.
     * \param instance iGeom instance handle
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of spatial coordinates input
     * \param coordinates Coordinates being queried
     * \param coordinates_size Number of coordinates in array
     * \param uv Coordinates of parametric positions
     * \param uv_allocated Allocated size of coordinates array
     * \param uv_size Occupied size of coordinates array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrXYZtoUV( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double const* coordinates,
                            int coordinates_size,
                            double** uv,
                            int* uv_allocated,
                            int* uv_size,
                            int* err );

    /**\brief  Return spatial positions at specified parametric position(s) on
     *         entity(ies)
     *
     * Return spatial positions at specified parametric position(s) on
     * entity(ies). If either the number of entities or number of spatial
     * coordinate triples is unity, then all points or entities are queried for
     * that entity or point, respectively, otherwise each point corresponds to
     * each entity.  storage_order should be a value in the iBase_StorageOrder
     * enum.
     * \param instance iGeom instance handle
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of spatial coordinates input
     * \param coordinates Coordinates being queried
     * \param coordinates_size Number of coordinates in array
     * \param u Coordinates of parametric positions
     * \param u_allocated Allocated size of coordinates array
     * \param u_size Occupied size of coordinates array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrXYZtoU( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle const* entity_handles,
                           int entity_handles_size,
                           int storage_order,
                           double const* coordinates,
                           int coordinates_size,
                           double** u,
                           int* u_allocated,
                           int* u_size,
                           int* err );

    /**\brief  Return parametric position at specified spatial position on
     *         entity, based on parametric position hint
     *
     * Return parametric position at specified spatial position on entity,
     * based on parametric position hint.  For this function, u and v are input
     * with parameters from which to start search. Typically this will reduce
     * the search time for new parametric coordinates.
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param x Spatial coordinate being queried
     * \param y Spatial coordinate being queried
     * \param z Spatial coordinate being queried
     * \param u Parametric coordinate at spatial position being queried
     * \param v Parametric coordinate at spatial position being queried
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntXYZtoUVHint( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                                iBase_EntityHandle entity_handle,
                                double x,
                                double y,
                                double z,
                                double* u,
                                double* v,
                                int* err );

    /**\brief  Return parametric positions at specified spatial position(s) on
     *         entity(ies), based on parametric position hints
     * Return parametric positions at specified spatial position(s) on
     * entity(ies), based on parametric position hints.  If either the number of
     * entities or number of spatial coordinate triples is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of spatial coordinates input
     * \param coordinates Coordinates being queried
     * \param coordinates_size Number of coordinates in array
     * \param uv Coordinates of parametric positions
     * \param uv_allocated Allocated size of coordinates array
     * \param uv_size Occupied size of coordinates array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrXYZtoUVHint( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                                iBase_EntityHandle const* entity_handles,
                                int entity_handles_size,
                                int storage_order,
                                double const* coords,
                                int coords_size,
                                double** uv,
                                int* uv_allocated,
                                int* uv_size,
                                int* err );

    /**\brief  Get parametric range of entity
     *
     * Get parametric range of entity
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param u_min Minimum parametric coordinate for entity
     * \param v_min Minimum parametric coordinate for entity
     * \param u_max Maximum parametric coordinate for entity
     * \param v_max Maximum parametric coordinate for entity
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntUVRange( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle entity_handle,
                            double* u_min,
                            double* v_min,
                            double* u_max,
                            double* v_max,
                            int* err );

    /**\brief  Get parametric range of entity
     *
     * Get parametric range of entity
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param u_min Minimum parametric coordinate for entity
     * \param u_max Maximum parametric coordinate for entity
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntURange( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle entity_handle,
                           double* u_min,
                           double* u_max,
                           int* err );

    /**\brief  Get parametric range of entities
     *
     * Get parametric range of entities
     * \param instance iGeom instance handle
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of parametric coordinates being
     *        returned
     * \param uv_min Minimum parametric coordinate for entities
     * \param uv_min_allocated Allocated size of minimum parametric coordinate
     *        array
     * \param uv_min_size Occupied size of minimum parametric coordinate array
     * \param uv_max Maximum parametric coordinate for entities
     * \param uv_max_allocated Allocated size of maximum parametric coordinate
     *        array
     * \param uv_max_size Occupied size of maximum parametric coordinate array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrUVRange( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double** uv_min,
                            int* uv_min_allocated,
                            int* uv_min_size,
                            double** uv_max,
                            int* uv_max_allocated,
                            int* uv_max_size,
                            int* err );

    /**\brief  Get parametric range of entities
     *
     * Get parametric range of entities
     * \param instance iGeom instance handle
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param storage_order Storage order of parametric coordinates being
     *        returned
     * \param u_min Minimum parametric coordinate for entities
     * \param u_min_allocated Allocated size of minimum parametric coordinate
     *        array
     * \param u_min_size Occupied size of minimum parametric coordinate array
     * \param u_max Maximum parametric coordinate for entities
     * \param u_max_allocated Allocated size of maximum parametric coordinate
     *        array
     * \param u_max_size Occupied size of maximum parametric coordinate array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrURange( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle const* entity_handles,
                           int entity_handles_size,
                           double** u_min,
                           int* u_min_allocated,
                           int* u_min_size,
                           double** u_max,
                           int* u_max_allocated,
                           int* u_max_size,
                           int* err );

    /**\brief  Return the face parametric coordinates for a parametric position
     *         on a bounding edge
     *
     * Return the face parametric coordinates for a parametric position on a
     * bounding edge
     * \param instance iGeom instance handle
     * \param edge_handle Edge being queried
     * \param face_handle Face being queried
     * \param in_u Parametric position on edge
     * \param u Corresponding parametric position on face
     * \param v Corresponding parametric position on face
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntUtoUV( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntityHandle edge_handle,
                          iBase_EntityHandle face_handle,
                          double in_u,
                          double* u,
                          double* v,
                          int* err );

    /**\brief  Return parametric coordinates on face of vertex position
     *
     * Return parametric coordinates on face of vertex position
     * \param instance iGeom instance handle
     * \param vertex_handle Vertex being queried
     * \param face_handle Face being queried
     * \param u Corresponding parametric position on face
     * \param v Corresponding parametric position on face
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getVtxToUV( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityHandle vertex_handle,
                         iBase_EntityHandle face_handle,
                         double* u,
                         double* v,
                         int* err );

    /**\brief  Return parametric coordinates on edge of vertex position
     *
     * Return parametric coordinates on edge of vertex position
     * \param instance iGeom instance handle
     * \param vertex_handle Vertex being queried
     * \param edge_handle Edge being queried
     * \param u Corresponding parametric position on face
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getVtxToU( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntityHandle vertex_handle,
                        iBase_EntityHandle edge_handle,
                        double* u,
                        int* err );

    /**\brief  Return the face parametric coordinates for a parametric position
     *         on bounding edges
     *
     * Return the face parametric coordinates for a parametric position on
     * bounding edges
     * \param instance iGeom instance handle
     * \param edge_handles Edges being queried
     * \param edge_handles_size Number of edges being queried
     * \param face_handles Faces being queried
     * \param face_handles_size Number of faces being queried
     * \param u_in Parametric positions on edges
     * \param u_in_size Number of parametric positions on edges
     * \param storage_order Storage order of coordinates returned
     * \param uv Corresponding parametric positions on faces
     * \param uv_allocated Allocated size of parameter array
     * \param uv_size Occupied size of parameter array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrUtoUV( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntityHandle const* edge_handles,
                          int edge_handles_size,
                          iBase_EntityHandle const* face_handles,
                          int face_handles_size,
                          double const* u_in,
                          int u_in_size,
                          int storage_order,
                          double** uv,
                          int* uv_allocated,
                          int* uv_size,
                          int* err );

    /**\brief  Return parametric coordinates on faces of vertex positions
     *
     * Return parametric coordinates on faces of vertex positions
     * \param instance iGeom instance handle
     * \param vertex_handles Vertices being queried
     * \param vertex_handles_size Number of vertices being queried
     * \param face_handles Faces being queried
     * \param face_handles_size Number of faces being queried
     * \param storage_order Storage order of coordinates returned
     * \param uv Corresponding parametric positions on faces
     * \param uv_allocated Allocated size of positions array
     * \param uv_size Occupied size of positions array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getVtxArrToUV( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle const* vertex_handles,
                            int vertex_handles_size,
                            iBase_EntityHandle const* face_handles,
                            int face_handles_size,
                            int storage_order,
                            double** uv,
                            int* uv_allocated,
                            int* uv_size,
                            int* err );

    /**\brief  Return parametric coordinates on edges of vertex positions
     *
     * Return parametric coordinates on edges of vertex positions
     * \param instance iGeom instance handle
     * \param vertex_handles Vertices being queried
     * \param vertex_handles_size Number of vertices being queried
     * \param edge_handles Edges being queried
     * \param edge_handles_size Number of edges being queried
     * \param u Corresponding parametric positions on faces
     * \param u_allocated Allocated size of positions array
     * \param u_size Occupied size of positions array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getVtxArrToU( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle const* vertex_handles,
                           int vertex_handles_size,
                           iBase_EntityHandle const* edge_handles,
                           int edge_handles_size,
                           double** u,
                           int* u_allocated,
                           int* u_size,
                           int* err );

    /**\brief  Return the normal at a specified parametric position
     *
     * Return the normal at a specified parametric position
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param u Parametric position being queried
     * \param v Parametric position being queried
     * \param nrml_i Normal at specified position
     * \param nrml_j Normal at specified position
     * \param nrml_k Normal at specified position
     * \param *err Pointer to error type returned from functino
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntNrmlUV( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle entity_handle,
                           double u,
                           double v,
                           double* nrml_i,
                           double* nrml_j,
                           double* nrml_k,
                           int* err );

    /**\brief  Return the normals at specified parametric positions
     *
     * Return the normals at specified parametric positions.  If either the
     * number of entities or number of spatial coordinate pairs is unity, then
     * all points or entities are queried for that entity or point,
     * respectively, otherwise each point corresponds to each entity.
     * storage_order should be a value in the iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param face_handle Faces being queried
     * \param face_handles_size Number of faces being queried
     * \param storage_order Storage order of coordinates input and output
     * \param parameters Parametric coordinates being queried
     * \param parameters_size Number of coordinates in array
     * \param normals Coordinates of normals at specified positions
     * \param normals_allocated Allocated size of normals array
     * \param normals_size Occupied size of normals array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrNrmlUV( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle const* face_handles,
                           int face_handles_size,
                           int storage_order,
                           double const* parameters,
                           int parameters_size,
                           double** normals,
                           int* normals_allocated,
                           int* normals_size,
                           int* err );

    /**\brief  Return the tangent at a specified parametric position
     *
     * Return the tangent at a specified parametric position
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param u Parametric position being queried
     * \param tgnt_i Tangent at specified position
     * \param tgnt_j Tangent at specified position
     * \param tgnt_k Tangent at specified position
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntTgntU( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntityHandle entity_handle,
                          double u,
                          double* tgnt_i,
                          double* tgnt_j,
                          double* tgnt_k,
                          int* err );

    /**\brief  Return the tangents at specified parametric positions
     *
     * Return the tangents at specified parametric positions.  If either the
     * number of entities or number of spatial coordinates is unity, then all
     * points or entities are queried for that entity or point, respectively,
     * otherwise each point corresponds to each entity.  storage_order should be
     * a value in the iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param edge_handle Edges being queried
     * \param edge_handles_size Number of faces being queried
     * \param storage_order Storage order of coordinates output
     * \param parameters Parametric coordinates being queried
     * \param parameters_size Number of coordinates in array
     * \param tangents Coordinates of tangents at specified positions
     * \param tangents_allocated Allocated size of tangents array
     * \param tangents_size Occupied size of tangents array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrTgntU( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntityHandle const* edge_handles,
                          int edge_handles_size,
                          int storage_order,
                          double const* parameters,
                          int parameters_size,
                          double** tangents,
                          int* tangents_allocated,
                          int* tangents_size,
                          int* err );

    /**\brief  Get the first derivative of a face at specified parametric
     *         position
     *
     * Get the first derivative of a face at specified parametric position.
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param u Parametric position being queried
     * \param v Parametric position being queried
     * \param dvrt_u Pointer to coordinates of derivative with respect to u at
     *        specified position returned from function
     * \param dvrt_u_allocated Allocated size of dvrt_u array
     * \param dvrt_u_size Occupied size of dvrt_u array
     * \param dvrt_v Pointer to coordinates of derivative with respect to v at
     *        specified position returned from function
     * \param dvrt_v_allocated Allocated size of dvrt_v array
     * \param dvrt_v_size Occupied size of dvrt_v array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEnt1stDrvt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle entity_handle,
                            double u,
                            double v,
                            double** drvt_u,
                            int* drvt_u_allocated,
                            int* drvt_u_size,
                            double** drvt_v,
                            int* dvrt_v_allocated,
                            int* dvrt_v_size,
                            int* err );

    /**\brief  Get the first derivatives of faces at specified parametric
     *         positions
     *
     * Get the first derivatives of faces at specified parametric positions.
     * storage_order should be a value in the iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param entity_handles Array of entity handles being queried
     * \param entity_handles_size Number of entities in entity_handles array
     * \param storage_order Storage order of coordinates input and output
     * \param uv Parametric coordinates being queried
     * \param uv_size Number of coordinates in array
     * \param dvrt_u Pointer to array of coordinates of derivative with respect
     *        to u at specified position returned from function
     * \param dvrt_u_allocated Allocated size of dvrt_u array
     * \param dvrt_u_size Occupied size of dvrt_u array
     * \param u_offset Pointer to array of offsets for dvrt_u returned from
     *        function
     * \param u_offset_allocated Pointer to allocated size of u_offset array
     * \param u_offset_size Pointer to occupied size of u_offset array
     * \param dvrt_v Pointer to array of coordinates of derivative with respect
     *        to v at specified position returned from function
     * \param dvrt_v_allocated Allocated size of dvrt_v array
     * \param dvrt_v_size Occupied size of dvrt_v array
     * \param v_offset Pointer to array of offsets for dvrt_v returned from
     *        function
     * \param v_offset_allocated Pointer to allocated size of v_offset array
     * \param v_offset_size Pointer to occupied size of v_offset array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArr1stDrvt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double const* uv,
                            int uv_size,
                            double** dvrt_u,
                            int* dvrt_u_allocated,
                            int* dvrt_u_size,
                            int** u_offset,
                            int* u_offset_allocated,
                            int* u_offset_size,
                            double** dvrt_v,
                            int* dvrt_v_allocated,
                            int* dvrt_v_size,
                            int** v_offset,
                            int* v_offset_allocated,
                            int* v_offset_size,
                            int* err );

    /**\brief  Get the second derivative of a face at specified parametric
     *         position
     *
     * Get the second derivative of a face at specified parametric position.
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param u Parametric position being queried
     * \param v Parametric position being queried
     * \param dvrt_uu Pointer to coordinates of derivative with respect to u at
     *        specified position returned from function
     * \param dvrt_uu_allocated Allocated size of dvrt_uu array
     * \param dvrt_uu_size Occupied size of dvrt_uu array
     * \param dvrt_vv Pointer to coordinates of derivative with respect to v at
     *        specified position returned from function
     * \param dvrt_vv_allocated Allocated size of dvrt_vv array
     * \param dvrt_vv_size Occupied size of dvrt_vv array
     * \param dvrt_uv Pointer to coordinates of derivative with respect to u and
     *        v at specified position returned from function
     * \param dvrt_uv_allocated Allocated size of dvrt_uv array
     * \param dvrt_uv_size Occupied size of dvrt_uv array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEnt2ndDrvt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle entity_handle,
                            double u,
                            double v,
                            double** drvt_uu,
                            int* drvt_uu_allocated,
                            int* drvt_uu_size,
                            double** drvt_vv,
                            int* dvrt_vv_allocated,
                            int* dvrt_vv_size,
                            double** drvt_uv,
                            int* dvrt_uv_allocated,
                            int* dvrt_uv_size,
                            int* err );

    /**\brief  Get the second derivatives of faces at specified parametric
     *         positions
     *
     * Get the second derivatives of faces at specified parametric positions.
     * storage_order should be a value in the iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param entity_handles Array of entity handles being queried
     * \param entity_handles_size Number of entities in entity_handles array
     * \param storage_order Storage order of coordinates input and output
     * \param uv Parametric coordinates being queried
     * \param uv_size Number of coordinates in array
     * \param dvrt_uu Pointer to array of coordinates of derivative with respect
     *        to u at specified position returned from function
     * \param dvrt_uu_allocated Allocated size of dvrt_uu array
     * \param dvrt_uu_size Occupied size of dvrt_uu array
     * \param uu_offset Pointer to array of offsets for dvrt_uu returned from
     *        function
     * \param uu_offset_allocated Pointer to allocated size of uu_offset array
     * \param uu_offset_size Pointer to occupied size of uu_offset array
     * \param dvrt_vv Pointer to array of coordinates of derivative with respect
     *        to v at specified position returned from function
     * \param dvrt_vv_allocated Allocated size of dvrt_vv array
     * \param dvrt_vv_size Occupied size of dvrt_vv array
     * \param vv_offset Pointer to array of offsets for dvrt_vv returned from
     *        function
     * \param vv_offset_allocated Pointer to allocated size of vv_offset array
     * \param vv_offset_size Pointer to occupied size of vv_offset array
     * \param dvrt_uv Pointer to array of coordinates of derivative with respect
     *        to u and v at specified position returned from function
     * \param dvrt_uv_allocated Allocated size of dvrt_uv array
     * \param dvrt_uv_size Occupied size of dvrt_uv array
     * \param uv_offset Pointer to array of offsets for dvrt_uv returned from
     *        function
     * \param uv_offset_allocated Pointer to allocated size of uv_offset array
     * \param uv_offset_size Pointer to occupied size of uv_offset array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArr2ndDrvt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int storage_order,
                            double const* uv,
                            int uv_size,
                            double** dvtr_uu,
                            int* dvrt_uu_allocated,
                            int* dvrt_uu_size,
                            int** uu_offset,
                            int* uu_offset_allocated,
                            int* uu_offset_size,
                            double** dvtr_vv,
                            int* dvrt_vv_allocated,
                            int* dvrt_vv_size,
                            int** vv_offset,
                            int* vv_offset_allocated,
                            int* vv_offset_size,
                            double** dvrt_uv,
                            int* dvrt_uv_allocated,
                            int* dvrt_uv_size,
                            int** uv_offset,
                            int* uv_offset_allocated,
                            int* uv_offset_size,
                            int* err );

    /**\brief  Get the two principle curvature vectors for a face at a
     *         parametric position
     *
     * Get the two principle curvature vectors for a face at a parametric
     * position.  Magnitudes of vectors are curvature, directions are
     * directions of principal curvatures.   
     * \param instance iGeom instance handle
     * \param face_handle Face being queried
     * \param u Parametric position being queried
     * \param v Parametric position being queried
     * \param cvtr1_i Maximum curvature vector
     * \param cvtr1_j Maximum curvature vector
     * \param cvtr1_k Maximum curvature vector
     * \param cvtr2_i Minimum curvature vector
     * \param cvtr2_j Minimum curvature vector
     * \param cvtr2_k Minimum curvature vector
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getFcCvtrUV( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntityHandle face_handle,
                          double u,
                          double v,
                          double* cvtr1_i,
                          double* cvtr1_j,
                          double* cvtr1_k,
                          double* cvtr2_i,
                          double* cvtr2_j,
                          double* cvtr2_k,
                          int* err );

    /**\brief  Get the curvature(s) on face(s) at given parametric position(s)
     *
     * Get the curvature(s) on face(s) at given parametric position(s).  If
     * either the number of faces or number of coordinate pairs is unity, then
     * all points or entities are queried for that entity or point,
     * respectively, otherwise each point corresponds to each entity.
     * storage_order should be a value in the iBase_StorageOrder enum.
     * \param instance iGeom instance handle
     * \param face_handles Face(s) being queried
     * \param face_handles_size Number of entities being queried
     * \param storage_order Storage order of uv coordinates
     * \param uv Starting parametric coordinates
     * \param uv_size Number of values in uv array
     * \param cvtr_1 First principal curvatures
     * \param cvtr_1_allocated Allocated size of first curvature array
     * \param cvtr_1_size Occupied size of first curvature array
     * \param cvtr_2 Second principal curvatures
     * \param cvtr_2_allocated Allocated size of second curvature array
     * \param cvtr_2_size Occupied size of second curvature array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getFcArrCvtrUV( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                             iBase_EntityHandle const* face_handles,
                             int face_handles_size,
                             int storage_order,
                             double const* uv,
                             int uv_size,
                             double** cvtr_1,
                             int* cvtr_1_allocated,
                             int* cvtr_1_size,
                             double** cvtr_2,
                             int* cvtr_2_allocated,
                             int* cvtr_2_size,
                             int* err );

    /**\brief  Return whether an entity is periodic
     *
     * Return whether an entity is periodic (=1) or not (=0) in the u and v
     * directions.
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param in_u Entity is periodic in u direction (=1) or not (=0)
     * \param in_v Entity is periodic in v direction (=1) or not (=0)
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isEntPeriodic( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle entity_handle,
                            int* in_u,
                            int* in_v,
                            int* err );

    /**\brief  Return whether entities are periodic
     *
     * Return whether entities are periodic (=1) or not (=0) in the u and v
     * directions.
     * \param instance iGeom instance handle
     * \param entity_handles Entities being queried
     * \param entity_handles_size Number of entities being queried
     * \param in_uv Array of pairs of integers representing whether
     *        entity_handles[i] is periodic (=1) or not (=0) in u and v
     *        directions
     * \param in_uv_allocated Allocated size of in_uv array
     * \param in_uv_size Occupied size of in_uv array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isArrPeriodic( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle const* entity_handles,
                            int entity_handles_size,
                            int** in_uv,
                            int* in_uv_allocated,
                            int* in_uv_size,
                            int* err );

    /**\brief  Return whether a face is degenerate
     *
     * Return whether a face is degenerate (=1) or not (=0).
     * \param instance iGeom instance handle
     * \param face_handle Face being queried
     * \param is_degenerate Face is degenerate (=1) or not (=0)
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isFcDegenerate( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                             iBase_EntityHandle face_handle,
                             int* is_degenerate,
                             int* err );

    /**\brief  Return whether faces are degenerate
     *
     * Return whether faces are degenerate (=1) or not (=0).
     * \param instance iGeom instance handle
     * \param face_handles Faces being queried
     * \param face_handles_size Number of faces being queried
     * \param degenerate face_handles[i] is degenerate (=1) or not (=0)
     * \param degenerate_allocated Allocated size of degenerate array
     * \param degenerate_size Occupied size of degenerate array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isFcArrDegenerate( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                                iBase_EntityHandle const* face_handles,
                                int face_handles_size,
                                int** degenerate,
                                int* degenerate_allocated,
                                int* degenerate_size,
                                int* err );

    /**\brief  Get the tolerance of the instance
     *
     * Get the tolerance at the modeler level.  type is an integer representing
     * the type of the tolerance, where 0 = no tolerance information,
     * 1 = modeler-level tolerance, 2 = entity-level tolerances.  If type is 1,
     * tolerance returns the modeler-level tolerance.  If type is 2, use
     * iGeom_getEntTolerance to query the tolerance on a per-entity basis.
     * \param instance iGeom instance handle
     * \param type Type of tolerance used by the modeler
     * \param tolerance Modeler-level tolerance, if any
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getTolerance( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           int* type,
                           double* tolerance,
                           int* err );

    /**\brief  Get the tolerance of the specified entity
     *
     * Get the tolerance of the specified entity.
     * \param instance iGeom instance handle
     * \param entity_handle Entity handle being queried
     * \param tolerance Pointer to tolerance returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntTolerance( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle entity_handle,
                              double* tolerance,
                              int* err );

    /**\brief  Get the tolerances of the specified entities
     *
     * Get the tolerances of the specified entities.
     * \param instance iGeom instance handle
     * \param entity_handles Array of entity handles being queried
     * \param entity_handles_size Number of entities in entity_handles array
     * \param tolerance Pointer to array of tolerances returned from function
     * \param tolerance_allocated Pointer to allocated size of tolerance array
     * \param tololerance_size Pointer to occupied size of tolerance array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrTolerance( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityHandle const* entity_handles,
                              int entity_handles_size,
                              double** tolerances,
                              int* tolerances_allocated,
                              int* tolerances_size,
                              int* err );

    /**\brief  Initialize an iterator over specified entity type
     *
     * Initialize an iterator over specified entity type for a specified set or
     * instance.  Iterator returned can be used as input to functions returning
     * the entity for the iterator.  If all entities of a specified type are to
     * be iterated, specify iBase_ALL_TYPES.  Specified type must be a value in
     * the iBase_EntityType enumeration.
     * \param instance iGeom instance handle
     * \param entity_set_handle Entity set being iterated
     * \param requested_entity_type Type of entity to iterate
     * \param entity_iterator Pointer to iterator returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_initEntIter( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntitySetHandle entity_set_handle,
                          int requested_entity_type,
                          iBase_EntityIterator* entity_iterator,
                          int* err );

    /**\brief  Initialize an array iterator over specified entity type and size
     *
     * Initialize an array iterator over specified entity type and size for a
     * specified set or instance.  Iterator returned can be used as input to
     * functions returning entities for the iterator.  If all entities of a
     * specified type are to be iterated, specify iBase_ALL_TYPES. Specified
     * type must be a value in the iBase_EntityType enumerations.
     * \param instance iGeom instance handle
     * \param entity_set_handle Entity set being iterated
     * \param requested_entity_type Type of entity to iterate
     * \param requested_array_size Size of chunks of handles returned for each
     *        value of the iterator
     * \param entArr_iterator Pointer to iterator returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_initEntArrIter( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                             iBase_EntitySetHandle entity_set_handle,
                             int requested_entity_type,
                             int requested_array_size,
                             iBase_EntityArrIterator* entArr_iterator,
                             int* err );

    /**\brief  Get entity corresponding to an iterator and increment iterator
     *
     * Get the entity corresponding to an array iterator, and increment the 
     * iterator.  Also return whether the next value of the iterator has
     * an entity (if non-zero, next iterator value is the end of the
     * iteration).
     * \param instance iGeom instance handle
     * \param entity_iterator Iterator being queried
     * \param entity_handle Pointer to an entity handle corresponding to the
     *        current value of iterator
     * \param has_data Pointer to a flag indicating if the value returned
     *        in entity_handle is valid. A non-zero value indicates the value
     *        is valid. A zero value indicates the value is NOT valid.
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getNextEntIter( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                             iBase_EntityIterator entity_iterator,
                             iBase_EntityHandle* entity_handle,
                             int* has_data,
                             int* err );

    /**\brief  Get entities contained in array iterator and increment iterator
     *
     * Get the entities contained in an array iterator, and increment the 
     * iterator.  Also return whether the next value of the iterator has
     * any entities (if non-zero, next iterator value is the end of the
     * iteration).
     * \param instance iGeom instance handle
     * \param entArr_iterator Iterator being queried
     * \param *entity_handles Pointer to array of entity handles contained in
     *        current value of iterator
     * \param *entity_handles_allocated Pointer to allocated size of 
     *        entity_handles array
     * \param *entity_handles_size Pointer to occupied size of entity_handles 
     *        array
     * \param has_data Pointer to a flag indicating if the value(s) returned
     *        in entity_handles are valid. A non-zero value indicates the 
     *        value(s) are valid. A zero value indicates the value(s) are NOT
     *        valid.
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getNextEntArrIter( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                                iBase_EntityArrIterator entArr_iterator,
                                iBase_EntityHandle** entity_handles,
                                int* entity_handles_allocated,
                                int* entity_handles_size,
                                int* has_data,
                                int* err );

    /**\brief  Reset the iterator
     *
     * Reset the iterator
     * \param instance iGeom instance handle
     * \param entity_iterator Iterator to reset
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_resetEntIter( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityIterator entity_iterator,
                           int* err );

    /**\brief  Reset the array iterator
     *
     * Reset the array iterator
     * \param instance iGeom instance handle
     * \param entArr_iterator Iterator to reset
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_resetEntArrIter( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntityArrIterator entArr_iterator,
                              int* err );

    /**\brief  Destroy the specified iterator
     *
     * Destroy the specified iterator
     * \param instance iGeom instance handle
     * \param entity_iterator Iterator which gets destroyed
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_endEntIter( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityIterator entity_iterator,
                         int* err );

    /**\brief  Destroy the specified array iterator
     *
     * Destroy the specified array iterator
     * \param instance iGeom instance handle
     * \param entArr_iterator Iterator which gets destroyed
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_endEntArrIter( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityArrIterator entArr_iterator,
                            int* err );

    /**\brief  Make a copy of the specified entity
     *
     * Make a copy of the specified entity
     * \param instance iGeom instance handle
     * \param source entity to be copied
     * \param copy the newly-created entity
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_copyEnt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                      iBase_EntityHandle source,
                      iBase_EntityHandle* copy,
                      int* err );

    /**\brief  Sweep (extrude) an entity about an axis
     *
     * Sweep (extrude) an entity by the given angle about the given axis.
     *
     * \param instance iGeom instance handle
     * \param geom_entity the entity to rotate
     * \param angle the rotational angle, in degrees
     * \param axis_x x coordinate of the axis
     * \param axis_y y coordinate of the axis
     * \param axis_z z coordinate of the axis
     * \param geom_entity2 Pointer to new entity handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_sweepEntAboutAxis( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                                iBase_EntityHandle geom_entity,
                                double angle,
                                double axis_x,
                                double axis_y,
                                double axis_z,
                                iBase_EntityHandle* geom_entity2,
                                int* err );

    /**\brief  Delete all entities and sets
     *
     * Delete all entities and sets
     * \param instance iGeom instance handle
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_deleteAll( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        int* err );

    /**\brief  Delete specified entity
     *
     * Delete specified entity
     * \param instance iGeom instance handle
     * \param entity_handle Entity to be deleted
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_deleteEnt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntityHandle entity_handle,
                        int* err );

    /**\brief Create a sphere
     *
     * Create a sphere of the specified radius centered on the origin.
     * \param instance iGeom instance handle
     * \param radius radius of the sphere
     * \param geom_entity Pointer to new entity handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_createSphere( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           double radius,
                           iBase_EntityHandle* geom_entity,
                           int* err );

    /**\brief  Create a prism
     *
     * Create a prism parallel to the z-axis and centered at the origin (so
     * that its z-coordinate extents are +height/2 and -height/2).
     * \param instance iGeom instance handle
     * \param height height of new prism
     * \param n_sides number of sides of new prism
     * \param major_rad major radius of new prism
     * \param minor_rad minor radius of new prism
     * \param geom_entity Pointer to new entity handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_createPrism( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          double height,
                          int n_sides,
                          double major_rad,
                          double minor_rad,
                          iBase_EntityHandle* geom_entity,
                          int* err );

    /**\brief  Create an axis-oriented box 
     *
     * Create an axis-oriented box of the given dimensions, centered at the
     * origin.
     * \param instance iGeom instance handle
     * \param x x dimension of new box
     * \param y y dimension of new box
     * \param z z dimension of new box
     * \param geom_entity Pointer to new entity handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_createBrick( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          double x,
                          double y,
                          double z,
                          iBase_EntityHandle* geom_entity,
                          int* err );

    /**\brief  Create a cylinder
     *
     * Create a cylinder parallel to the z-axis and centered at the origin (so
     * that its z-coordinate extents are +height/2 and -height/2).
     * \param instance iGeom instance handle
     * \param height The height of the cylinder.
     * \param major_rad The x-axis radius
     * \param minor_rad The y-axis radius. If minor_rad is 0, the cylinder will 
     *        be circular (as if minor_rad == major_rad).
     * \param geom_entity Pointer to new entity handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_createCylinder( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                             double height,
                             double major_rad,
                             double minor_rad,
                             iBase_EntityHandle* geom_entity,
                             int* err );

    /**\brief  Create a cone or tapered cylinder
     *
     * Create a cone parallel to the z-axis and centered at the origin (so that
     * its z-coordinate extents are +height/2 and -height/2). The 'base' of the
     * cylinder is at z = -height/2, and the top is at +height/2.
     * \param instance iGeom instance handle
     * \param height The height of the cone.
     * \param major_rad_base The x-axis radius at the base of the cylinder 
     * \param minor_rad_base The y-axis radius at the base.  If minor_rad_base
     *        is 0, the cylinder will be circular (as if minor_rad_base ==
     *        major_rad_base)
     * \param rad_top The x-axis radius at the top of the cone.  The y-axis
     *        radius at the top of the cone will be inferred to keep the aspect 
     *        ratio of the top of the cone the same as the bottom. If rad_top is
     *        0, the cone terminates at a point.
     * \param geom_entity Pointer to new entity handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_createCone( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         double height,
                         double major_rad_base,
                         double minor_rad_base,
                         double rad_top,
                         iBase_EntityHandle* geom_entity,
                         int* err );

    /**\brief  Create a torus
     *
     * Create a torus centered on the origin and encircling the z-axis.
     * \param instance iGeom instance handle
     * \param major_rad The distance from the origin to the center of the
     *        torus's circular cross-section.
     * \param minor_rad The radius of the cross-section.
     * \param geom_entity Pointer to new entity handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_createTorus( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          double major_rad,
                          double minor_rad,
                          iBase_EntityHandle* geom_entity,
                          int* err );

    /**\brief  Move an entity by the given vector
     *
     * Move an entity by translating it along the given vector.
     * \param instance iGeom instance handle
     * \param geom_entity the entity to move
     * \param x x coordinate of the vector
     * \param y y coordinate of the vector
     * \param z z coordinate of the vector
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_moveEnt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                      iBase_EntityHandle geom_entity,
                      double x,
                      double y,
                      double z,
                      int* err );

    /**\brief  Rotate an entity about an axis
     *
     * Rotate an entity by the given angle about the given axis.
     * \param instance iGeom instance handle
     * \param geom_entity the entity to rotate
     * \param angle the rotational angle, in degrees
     * \param axis_x x coordinate of the axis
     * \param axis_y y coordinate of the axis
     * \param axis_z z coordinate of the axis
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_rotateEnt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntityHandle geom_entity,
                        double angle,
                        double axis_x,
                        double axis_y,
                        double axis_z,
                        int* err );

   /**\brief  Reflect an entity across a plane
     *
     * Reflect an entity across the given plane
     * \param instance iGeom instance handle
     * \param geom_entity the entity to reflect
     * \param point_x  x coordinate of the point that the reflecting plane goes though
     * \param point_y  y coordinate of the point that the reflecting plane goes 
though
     * \param point_z  z coordinate of the point that the reflecting plane goes 
though
     * \param plane_normal_x x coordinate of the plane's normal
     * \param plane_normal_y y coordinate of the plane's normal
     * \param plane_normal_z z coordinate of the plane's normal
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_reflectEnt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityHandle geom_entity,
                         double point_x,
                         double point_y,
                         double point_z,
                         double plane_normal_x,
                         double plane_normal_y,
                         double plane_normal_z,
                         int* err );

   /**\brief  Scale an entity in the x, y, and z directions
     *
     * Scale an entity in the x, y, and z directions.
     * \param instance iGeom instance handle
     * \param geom_entity the entity to scale
     * \param point_x  x coordinate of the scaling center
     * \param point_y  y coordinate of the scaling center
     * \param point_z  z coordinate of the scaling center
     * \param scale_x factor to scale by in the x direction
     * \param scale_y factor to scale by in the y direction
     * \param scale_z factor to scale by in the z direction
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_scaleEnt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                       iBase_EntityHandle geom_entity,
                       double point_x,
                       double point_y,
                       double point_z,
                       double scale_x,
                       double scale_y,
                       double scale_z,
                       int* err );

    /**\brief  Geometrically unite entities
     *
     * Geometrically unite the specified entities.
     * \param instance iGeom instance handle
     * \param geom_entities Array of entity handles being united
     * \param geom_entities_size Number of entities in geom_entities array
     * \param geom_entity Pointer to new entity handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_uniteEnts( iGeom_Instance instace,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntityHandle const* geom_entities,
                        int geom_entities_size,
                        iBase_EntityHandle* geom_entity,
                        int* err );

    /**\brief  Geometrically subtract one entity from another
     *
     * Geometrically subtract the entity tool from the entity blank.
     * \param instance iGeom instance handle
     * \param blank The entity to subtract from
     * \param tool The entity to subtract
     * \param geom_entity Pointer to new entity handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_subtractEnts( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntityHandle blank,
                           iBase_EntityHandle tool,
                           iBase_EntityHandle* geom_entity,
                           int* err );

    /**\brief  Geometrically intersect a pair of entities
     *
     * Geometrically intersect a pair of entities.
     * \param instance iGeom instance handle
     * \param entity1 The entity to intersect
     * \param entity2 The entity to intersect
     * \param geom_entity Pointer to new entity handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_intersectEnts( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle entity2,
                            iBase_EntityHandle entity1,
                            iBase_EntityHandle* geom_entity,
                            int* err );

    /**\brief  Section (cut) a region with a plane
     *
     * Section (cut) a region with a plane, retaining one of the pieces and
     * discarding the other.
     * \param instance iGeom instance handle
     * \param geom_entity The entity to section
     * \param plane_normal_x x coordinate of the plane's normal
     * \param plane_normal_y y coordinate of the plane's normal
     * \param plane_normal_z z coordinate of the plane's normal
     * \param offset Distance of the plane from the origin
     * \param reverse Keep the piece on the normal's side (=0) or not (=1)
     * \param geom_entity2 Pointer to new entity handle returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_sectionEnt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityHandle geom_entity,
                         double plane_normal_x,
                         double plane_normal_y,
                         double plane_normal_z,
                         double offset,
                         int reverse,
                         iBase_EntityHandle* geom_entity2,
                         int* err );

    /**\brief  Imprint entities
     *
     * Imprint entities by merging coincident surfaces.
     * \param instance iGeom instance handle
     * \param geom_entities Array of entity handles being imprinted
     * \param geom_entities_size Number of entities in geom_entities array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_imprintEnts( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntityHandle const* geom_entities,
                          int geom_entities_size,
                          int* err );

    /**\brief  Merge ents
     *
     * Merge entities of corresponding topology/geometry within the specified
     * tolerance.
     * \param instance iGeom instance handle
     * \param geom_entities Array of entity handles being imprinted
     * \param geom_entities_size Number of entities in geom_entities array
     * \param tolerance Tolerance within which entities are considered the same
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_mergeEnts( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntityHandle const* geom_entities,
                        int geom_entities_size,
                        double tolerance,
                        int* err );

    /**\brief  Create an entity set
     *
     * Create an entity set, either ordered (isList=1) or unordered 
     * (isList=0).  Unordered entity sets can contain a given entity or 
     * set only once.
     * \param instance iGeom instance handle
     * \param isList If non-zero, an ordered list is created, otherwise an
     *        unordered set is created.
     * \param entity_set_created Entity set created by function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_createEntSet( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           int isList,
                           iBase_EntitySetHandle* entity_set_created, 
                           int *err );

    /**\brief  Destroy an entity set
     *
     * Destroy an entity set
     * \param instance iGeom instance handle
     * \param entity_set Entity set to be destroyed
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_destroyEntSet( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntitySetHandle entity_set, 
                            int *err );

    /**\brief  Return whether a specified set is ordered or unordered
     *
     * Return whether a specified set is ordered (*is_list=1) or 
     * unordered (*is_list=0)
     * \param instance iGeom instance handle
     * \param entity_set Entity set being queried
     * \param is_list Pointer to flag returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isList( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                     iBase_EntitySetHandle entity_set,
                     int *is_list, 
                     int *err );

    /**\brief  Get the number of entity sets contained in a set or interface
     *
     * Get the number of entity sets contained in a set or interface.  If
     * a set is input which is not the root set, num_hops indicates the 
     * maximum number of contained sets from entity_set_handle to one of the
     * contained sets, not inclusive of the contained set.
     * \param instance iGeom instance handle
     * \param entity_set_handle Entity set being queried
     * \param num_hops Maximum hops from entity_set_handle to contained set,
     *        not inclusive of the contained set
     * \param num_sets Pointer to the number of sets returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getNumEntSets( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntitySetHandle entity_set_handle,
                            int num_hops,
                            int *num_sets, 
                            int *err );

    /**\brief  Get the entity sets contained in a set or interface
     *
     * Get the entity sets contained in a set or interface.  If
     * a set is input which is not the root set, num_hops indicates the 
     * maximum number of contained sets from entity_set_handle to one of the
     * contained sets, not inclusive of the contained set.
     * \param instance iGeom instance handle
     * \param entity_set_handle Entity set being queried
     * \param num_hops Maximum hops from entity_set_handle to contained set,
     *        not inclusive of the contained set
     * \param *contained_set_handles Pointer to array of set handles returned
     *        from function
     * \param contained_set_handles_allocated Pointer to allocated length of
     *        contained_set_handles array
     * \param contained_set_handles_size Pointer to occupied length of
     *        contained_set_handles array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntSets( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntitySetHandle entity_set_handle,
                         int num_hops,
                         iBase_EntitySetHandle** contained_set_handles,
                         int* contained_set_handles_allocated,
                         int* contained_set_handles_size, 
                         int *err );

    /**\brief  Add an entity to a set
     *
     * Add an entity to a set
     * \param instance iGeom instance handle
     * \param entity_handle The entity being added
     * \param entity_set Pointer to the set being added to
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_addEntToSet( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntityHandle entity_handle,
                          iBase_EntitySetHandle entity_set, 
                          int *err );

    /**\brief  Remove an entity from a set
     *
     * Remove an entity from a set
     *
     * \param instance iGeom instance handle
     * \param entity_handle The entity being removed
     * \param entity_set Pointer to the set being removed from
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_rmvEntFromSet( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntityHandle entity_handle,
                            iBase_EntitySetHandle entity_set, 
                            int *err );

    /**\brief  Add an array of entities to a set
     *
     * Add an array of entities to a set
     * \param instance iGeom instance handle
     * \param entity_handles Array of entities being added
     * \param entity_handles_size Number of entities in entity_handles array
     * \param entity_set Pointer to the set being added to
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_addEntArrToSet( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                             const iBase_EntityHandle* entity_handles,
                             int entity_handles_size,
                             iBase_EntitySetHandle entity_set, 
                             int *err );

    /**\brief  Remove an array of entities from a set
     *
     * Remove an array of entities from a set
     * \param instance iGeom instance handle
     * \param entity_handles Array of entities being remove
     * \param entity_handles_size Number of entities in entity_handles array
     * \param entity_set Pointer to the set being removed from
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_rmvEntArrFromSet( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                               const iBase_EntityHandle* entity_handles,
                               int entity_handles_size,
                               iBase_EntitySetHandle entity_set,
                               int *err );

    /**\brief  Add an entity set to a set
     *
     * Add an entity set to a set
     * \param instance iGeom instance handle
     * \param entity_set_to_add The entity set being added
     * \param entity_set_handle Pointer to the set being added to
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_addEntSet( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntitySetHandle entity_set_to_add,
                        iBase_EntitySetHandle entity_set_handle, 
                        int *err);

    /**\brief  Remove an entity set from a set
     *
     * Remove an entity set from a set
     * \param instance iGeom instance handle
     * \param entity_set_to_remove The entity set being removed
     * \param entity_set_handle Pointer to the set being removed from
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_rmvEntSet( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntitySetHandle entity_set_to_remove,
                        iBase_EntitySetHandle entity_set_handle, 
                        int *err );

    /**\brief  Return whether an entity is contained in another set
     *
     * Return whether an entity is contained (*is_contained=1) or not 
     * contained (*is_contained=0) in another set
     * \param instance iGeom instance handle
     * \param containing_entity_set Entity set being queried
     * \param contained_entity Entity potentially contained in 
     *        containing_entity_set
     * \param is_contained Pointer to flag returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isEntContained( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                             iBase_EntitySetHandle containing_entity_set,
                             iBase_EntityHandle contained_entity,
                             int *is_contained, 
                             int *err );

    /**\brief  Return whether entities are contained in a set
     *
     * Return whether each entity is contained in the set.
     * \param instance iMesh instance handle
     * \param containing_entity_set Entity set being queried
     * \param entity_handles List of entities for which to check containment.
     * \param is_contained One value for each input entity, 1 if contained
     *          in set, zero otherwise.
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isEntArrContained( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                                /*in*/ iBase_EntitySetHandle containing_set,
                                /*in*/ const iBase_EntityHandle* entity_handles,
                                /*in*/ int num_entity_handles,
                                /*inout*/ int** is_contained,
                                /*inout*/ int* is_contained_allocated,
                                /*out*/ int* is_contained_size,
                                /*out*/ int* err );

    /**\brief  Return whether an entity set is contained in another set
     *
     * Return whether a set is contained (*is_contained=1) or not contained
     * (*is_contained=0) in another set
     * \param instance iGeom instance handle
     * \param containing_entity_set Entity set being queried
     * \param contained_entity_set Entity set potentially contained in 
     *        containing_entity_set
     * \param is_contained Pointer to flag returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isEntSetContained( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                                iBase_EntitySetHandle containing_entity_set,
                                iBase_EntitySetHandle contained_entity_set,
                                int *is_contained, 
                                int *err );

    /**\brief  Add parent/child links between two sets
     *
     * Add parent/child links between two sets.  Makes parent point to child
     * and child point to parent.
     * \param instance iGeom instance handle
     * \param parent_entity_set Pointer to parent set
     * \param child_entity_set Pointer to child set
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_addPrntChld( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntitySetHandle parent_entity_set,
                          iBase_EntitySetHandle child_entity_set, 
                          int *err );

    /**\brief  Remove parent/child links between two sets
     *
     * Remove parent/child links between two sets.
     * \param instance iGeom instance handle
     * \param parent_entity_set Pointer to parent set
     * \param child_entity_set Pointer to child set
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_rmvPrntChld( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntitySetHandle parent_entity_set,
                          iBase_EntitySetHandle child_entity_set, 
                          int *err );

    /**\brief  Return whether two sets are related by parent/child links
     *
     * Return whether two sets are related (*is_child=1) or not (*is_child=0)
     * by parent/child links
     * \param instance iGeom instance handle
     * \param parent_entity_set Pointer to parent set
     * \param child_entity_set Pointer to child set
     * \param is_child Pointer to flag returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_isChildOf( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntitySetHandle parent_entity_set,
                        iBase_EntitySetHandle child_entity_set,
                        int *is_child, 
                        int *err );

    /**\brief  Get the number of child sets linked from a specified set
     *
     * Get the number of child sets linked from a specified set.  If num_hops
     * is not -1, this represents the maximum hops from entity_set to any
     * child in the count.
     * \param instance iGeom instance handle
     * \param entity_set Entity set being queried
     * \param num_hops Maximum hops from entity_set_handle to child set,
     *        not inclusive of the child set
     * \param num_child Pointer to number of children returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getNumChld( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntitySetHandle entity_set,
                         int num_hops,
                         int *num_child, 
                         int *err );

    /**\brief  Get the number of parent sets linked from a specified set
     *
     * Get the number of parent sets linked from a specified set.  If num_hops
     * is not -1, this represents the maximum hops from entity_set to any
     * parent in the count.
     * \param instance iGeom instance handle
     * \param entity_set Entity set being queried
     * \param num_hops Maximum hops from entity_set_handle to parent set,
     *        not inclusive of the parent set
     * \param num_parent Pointer to number of parents returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getNumPrnt( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntitySetHandle entity_set,
                         int num_hops,
                         int *num_parent, 
                         int *err );

    /**\brief  Get the child sets linked from a specified set
     *
     * Get the child sets linked from a specified set.  If num_hops
     * is not -1, this represents the maximum hops from entity_set to any
     * child.
     * \param instance iGeom instance handle
     * \param from_entity_set Entity set being queried
     * \param num_hops Maximum hops from entity_set_handle to child set,
     *        not inclusive of the child set
     * \param *entity_set_handles Pointer to array of child sets
     *        returned from function
     * \param *entity_set_handles_allocated Pointer to allocated size of 
     *        entity_set_handles array
     * \param *entity_set_handles_size Pointer to occupied size of 
     *        entity_set_handles array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getChldn( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                       iBase_EntitySetHandle from_entity_set,
                       int num_hops,
                       iBase_EntitySetHandle** entity_set_handles,
                       int* entity_set_handles_allocated,
                       int* entity_set_handles_size, 
                       int *err );

    /**\brief  Get the parent sets linked from a specified set
     *
     * Get the parent sets linked from a specified set.  If num_hops
     * is not -1, this represents the maximum hops from entity_set to any
     * parent.
     * \param instance iGeom instance handle
     * \param from_entity_set Entity set being queried
     * \param num_hops Maximum hops from entity_set_handle to parent set,
     *        not inclusive of the parent set
     * \param *entity_set_handles Pointer to array of parent sets
     *        returned from function
     * \param *entity_set_handles_allocated Pointer to allocated size of 
     *        entity_set_handles array
     * \param *entity_set_handles_size Pointer to occupied size of 
     *        entity_set_handles array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getPrnts( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                       iBase_EntitySetHandle from_entity_set,
                       int num_hops,
                       iBase_EntitySetHandle** entity_set_handles,
                       int* entity_set_handles_allocated,
                       int* entity_set_handles_size, 
                       int *err );

    /**\brief  Create a tag with specified name, size, and type
     *
     * Create a tag with specified name, size, and type.  Tag size is in
     * units of size of tag_type data types.  Value input for tag type must be 
     * value in iBase_TagType enumeration.
     * \param instance iGeom instance handle
     * \param tag_name Character string indicating tag name
     * \param tag_size Size of each tag value, in units of number of tag_type 
     *        entities
     * \param tag_type Data type for data stored in this tag
     * \param tag_handle Pointer to tag handle returned from function
     * \param *err Pointer to error type returned from function
     * \param tag_name_len Length of tag name string
     */
  CGMA_IGEOM_EXPORT
  void iGeom_createTag( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        const char* tag_name,
                        int tag_size,
                        int tag_type,
                        iBase_TagHandle* tag_handle, 
                        int *err,
                        int tag_name_len );


    /**\brief  Destroy a tag
     *
     * Destroy a tag.  If forced is non-zero and entities still have values
     * set for this tag, tag is deleted anyway and those values disappear,
     * otherwise tag is not deleted.
     * \param instance iGeom instance handle
     * \param tag_handle Handle of tag to be deleted
     * \param forced If non-zero, delete the tag even if entities have values
     *        set for that tag
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_destroyTag( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_TagHandle tag_handle,
                         int forced, 
                         int *err);

    /**\brief  Get the name for a given tag handle
     *
     * Get the name for a given tag handle
     * \param instance iGeom instance handle
     * \param tag_handle Tag handle being queried
     * \param name Pointer to character string to store name returned from 
     *        function
     * \param *err Pointer to error type returned from function
     * \param name_len Length of character string input to function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getTagName( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_TagHandle tag_handle,
                         char *name, 
                         int* err,
                         int name_len );

    /**\brief  Get size of a tag in units of numbers of tag data type
     *
     * Get size of a tag in units of numbers of tag data type
     * \param instance iGeom instance handle
     * \param tag_handle Handle of tag being queried
     * \param tag_size Pointer to tag size returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getTagSizeValues( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                               iBase_TagHandle tag_handle,
                               int *tag_size, 
                               int *err );

    /**\brief  Get size of a tag in units of bytes
     *
     * Get size of a tag in units of bytes
     * \param instance iGeom instance handle
     * \param tag_handle Handle of tag being queried
     * \param tag_size Pointer to tag size returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getTagSizeBytes( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_TagHandle tag_handle,
                              int *tag_size, 
                              int *err );

    /**\brief  Get a the handle of an existing tag with the specified name
     *
     * Get a the handle of an existing tag with the specified name
     * \param instance iGeom instance handle
     * \param tag_name Name of tag being queried
     * \param tag_handle Pointer to tag handle returned from function
     * \param *err Pointer to error type returned from function
     * \param tag_name_len Length of tag name string
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getTagHandle( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           const char* tag_name,
                           iBase_TagHandle *tag_handle, 
                           int *err,
                           int tag_name_len );

    /**\brief  Get the data type of the specified tag handle
     *
     * Get the data type of the specified tag handle.  Tag type is a value in
     * the iBase_TagType enumeration.
     * \param instance iGeom instance handle
     * \param tag_handle Handle for the tag being queried
     * \param tag_type Pointer to tag type returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getTagType( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_TagHandle tag_handle,
                         int *tag_type, 
                         int *err );

    /**\brief  Set a tag value of arbitrary type on an entity set
     *
     * Set a tag value of arbitrary type on an entity set. The tag data
     * is passed as void*. tag_value_size specifies the size of the memory
     * pointed to by tag_value in terms of bytes. Applications are free to
     * use this function to set data of any type, not just iBase_BYTES.
     * However, in all cases, the size specified by tag_value_size is
     * always in terms of bytes.
     *
     * \param instance iGeom instance handle
     * \param entity_set_handle Entity set on which tag is being set
     * \param tag_handle Tag being set on an entity set
     * \param tag_value Pointer to tag data being set on entity set
     * \param tag_value_size Size in bytes of tag data
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setEntSetData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntitySetHandle entity_set_handle,
                            const iBase_TagHandle tag_handle,
                            const void* tag_value,
                            const int tag_value_size,
                            int *err );

    /**\brief  Set a tag value of integer type on an entity set
     *
     * Set a tag value of integer type on an entity set.
     * \param instance iGeom instance handle
     * \param entity_set Entity set on which tag is being set
     * \param tag_handle Tag being set on an entity set
     * \param tag_value Tag value being set on entity set
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setEntSetIntData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                               iBase_EntitySetHandle entity_set,
                               iBase_TagHandle tag_handle,
                               int tag_value, 
                               int *err );

    /**\brief  Set a tag value of double type on an entity set
     *
     * Set a tag value of double type on an entity set.
     * \param instance iGeom instance handle
     * \param entity_set Entity set on which tag is being set
     * \param tag_handle Tag being set on an entity set
     * \param tag_value Tag value being set on entity set
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setEntSetDblData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                               iBase_EntitySetHandle entity_set,
                               iBase_TagHandle tag_handle,
                               double tag_value, 
                               int *err );

    /**\brief  Set a tag value of entity handle type on an entity set
     *
     * Set a tag value of entity handle type on an entity set.
     * \param instance iGeom instance handle
     * \param entity_set Entity set on which tag is being set
     * \param tag_handle Tag being set on an entity set
     * \param tag_value Tag value being set on entity set
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setEntSetEHData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntitySetHandle entity_set,
                              iBase_TagHandle tag_handle,
                              iBase_EntityHandle tag_value, 
                              int *err );

    /**\brief  Set a tag value of entity set handle type on an entity set
     *
     * Set a tag value of entity set handle type on an entity set.
     * \param instance iGeom instance handle
     * \param entity_set Entity set on which tag is being set
     * \param tag_handle Tag being set on an entity set
     * \param tag_value Tag value being set on entity set
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setEntSetESHData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                               iBase_EntitySetHandle entity_set,
                               iBase_TagHandle tag_handle,
                               iBase_EntitySetHandle tag_value, 
                               int *err );

    /**\brief  Get the value of a tag of arbitrary type on an entity set
     *
     * Get the value of a tag of arbitrary type on an entity set.  Tag data 
     * is returned back as void*. tag_value_size specifies the size of the
     * memory pointed to by tag_value in terms of bytes. Applications may
     * use this function to get data of any type, not just iBase_BYTES.
     * However because this function supports data of arbitrary type,
     * in all cases the size specified by tag_value_size is always in terms
     * of bytes.
     *
     * \param instance iGeom instance handle
     * \param entity_set_handle Entity set on which tag is being set
     * \param tag_handle Tag being set on an entity set
     * \param *tag_value Pointer to tag data array being queried
     * \param *tag_value_allocated Pointer to tag data array allocated size
     * \param *tag_value_size Pointer to occupied size in bytes of tag data
     *        array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntSetData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            iBase_EntitySetHandle entity_set_handle,
                            iBase_TagHandle tag_handle,
                            void** tag_value,
                            int* tag_value_allocated,
                            int* tag_value_size, 
                            int *err );

    /**\brief  Get the value of a tag of integer type on an entity set
     *
     * Get the value of a tag of integer type on an entity set.
     * \param instance iGeom instance handle
     * \param entity_set Entity set on which tag is being set
     * \param tag_handle Tag being set on an entity set
     * \param *out_data Pointer to tag value returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntSetIntData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                               iBase_EntitySetHandle entity_set,
                               iBase_TagHandle tag_handle,
                               int *out_data, 
                               int *err );

    /**\brief  Get the value of a tag of double type on an entity set
     *
     * Get the value of a tag of double type on an entity set.
     * \param instance iGeom instance handle
     * \param entity_set Entity set on which tag is being set
     * \param tag_handle Tag being set on an entity set
     * \param *out_data Pointer to tag value returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntSetDblData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                               iBase_EntitySetHandle entity_set,
                               iBase_TagHandle tag_handle,
                               double *out_data, 
                               int *err );

    /**\brief  Get the value of a tag of entity handle type on an entity set
     *
     * Get the value of a tag of entity handle type on an entity set.
     * \param instance iGeom instance handle
     * \param entity_set Entity set on which tag is being set
     * \param tag_handle Tag being set on an entity set
     * \param *out_data Pointer to tag value returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntSetEHData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntitySetHandle entity_set,
                              iBase_TagHandle tag_handle,
                              iBase_EntityHandle *out_data, 
                              int *err );

    /**\brief  Get the value of a tag of entity set handle type on an entity set
     *
     * Get the value of a tag of entity set handle type on an entity set.
     * \param instance iGeom instance handle
     * \param entity_set Entity set on which tag is being set
     * \param tag_handle Tag being set on an entity set
     * \param *out_data Pointer to tag value returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEntSetESHData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                              iBase_EntitySetHandle entity_set,
                              iBase_TagHandle tag_handle,
                              iBase_EntitySetHandle *out_data, 
                              int *err );

    /**\brief  Get all the tags associated with a specified entity set
     *
     * Get all the tags associated with a specified entity set
     * \param instance iGeom instance handle
     * \param entity_set_handle Entity being queried
     * \param *tag_handles Pointer to array of tag_handles returned from 
     *        function
     * \param *tag_handles_allocated Pointer to allocated size of tag_handles 
     *        array
     * \param *tag_handles_size Pointer to occupied size of tag_handles array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getAllEntSetTags( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                               iBase_EntitySetHandle entity_set_handle,
                               iBase_TagHandle** tag_handles,
                               int* tag_handles_allocated,
                               int* tag_handles_size, 
                               int *err );

    /**\brief  Remove a tag value from an entity set
     *
     * Remove a tag value from an entity set
     * \param instance iGeom instance handle
     * \param entity_set_handle Entity set from which tag is being removed
     * \param tag_handle Tag handle of tag being removed
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_rmvEntSetTag( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           iBase_EntitySetHandle entity_set_handle,
                           iBase_TagHandle tag_handle, 
                           int *err );

    /**\brief  Get tag values of arbitrary type for an array of entities
     *
     * Get tag values of arbitrary type for an array of entities.  Tag data 
     * is returned as void*. tag_values_size specifies the size of the
     * memory pointed to by tag_values in terms of bytes. Applications may
     * use this function to get data of any type, not just iBase_BYTES.
     * However, because this function supports data of arbitrary type, in
     * all cases the size specified by tag_values_size always in terms of
     * bytes.
     *
     * \param instance iGeom instance handle
     * \param entity_handles Entity array on which tag is being set
     * \param entity_handles_size Number of entities in array
     * \param tag_handle Tag being set on an entity
     * \param *tag_values Pointer to tag data array being returned from 
     *        function. Note that the implicit INTERLEAVED storage
     *        order rule applies (see section ITAPS Storage Orders)
     * \param tag_values_allocated Pointer to allocated size of tag data array
     * \param tag_values_size Pointer to occupied size in bytes of tag data
     *        array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getArrData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         const iBase_EntityHandle* entity_handles,
                         int entity_handles_size,
                         iBase_TagHandle tag_handle,
                         void** tag_values,
                         int* tag_values_allocated,
                         int* tag_values_size, 
                         int *err );

    /**\brief  Get tag values of integer type for an array of entities
     *
     * Get tag values of integer type for an array of entities.
     * \param instance iGeom instance handle
     * \param entity_handles Entity array on which tag is being set
     * \param entity_handles_size Number of entities in array
     * \param tag_handle Tag being set on an entity
     * \param *tag_values Pointer to tag data array being returned from 
     *        function
     * \param tag_values_allocated Pointer to allocated size of tag data array
     * \param tag_values_size Pointer to occupied size of tag data array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getIntArrData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            const iBase_EntityHandle* entity_handles,
                            int entity_handles_size,
                            iBase_TagHandle tag_handle,
                            int** tag_values,
                            int* tag_values_allocated,
                            int* tag_values_size, 
                            int *err );

    /**\brief  Get tag values of double type for an array of entities
     *
     * Get tag values of double type for an array of entities.
     * \param instance iGeom instance handle
     * \param entity_handles Entity array on which tag is being set
     * \param entity_handles_size Number of entities in array
     * \param tag_handle Tag being set on an entity
     * \param *tag_values Pointer to tag data array being returned from 
     *        function
     * \param tag_values_allocated Pointer to allocated size of tag data array
     * \param tag_values_size Pointer to occupied size of tag data array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getDblArrData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            const iBase_EntityHandle* entity_handles,
                            int entity_handles_size,
                            iBase_TagHandle tag_handle,
                            double** tag_values,
                            int* tag_values_allocated,
                            int* tag_values_size, 
                            int *err );

    /**\brief  Get tag values of entity handle type for an array of entities
     *
     * Get tag values of entity handle type for an array of entities.
     * \param instance iGeom instance handle
     * \param entity_handles Entity array on which tag is being set
     * \param entity_handles_size Number of entities in array
     * \param tag_handle Tag being set on an entity
     * \param *tag_value Pointer to tag data array being returned from 
     *        function
     * \param tag_value_allocated Pointer to allocated size of tag data array
     * \param tag_value_size Pointer to occupied size of tag data array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEHArrData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           const iBase_EntityHandle* entity_handles,
                           int entity_handles_size,
                           iBase_TagHandle tag_handle,
                           iBase_EntityHandle** tag_value,
                           int* tag_value_allocated,
                           int* tag_value_size, 
                           int *err );

    /**\brief  Get tag values of entity set handle type for an array of entities
     *
     * Get tag values of entity set handle type for an array of entities.
     * \param instance iGeom instance handle
     * \param entity_handles Entity array on which tag is being set
     * \param entity_handles_size Number of entities in array
     * \param tag_handle Tag being set on an entity
     * \param *tag_value Pointer to tag data array being returned from 
     *        function
     * \param tag_value_allocated Pointer to allocated size of tag data array
     * \param tag_value_size Pointer to occupied size of tag data array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getESHArrData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            const iBase_EntityHandle* entity_handles,
                            int entity_handles_size,
                            iBase_TagHandle tag_handle,
                            iBase_EntitySetHandle** tag_value,
                            int* tag_value_allocated,
                            int* tag_value_size, 
                            int *err );


    /**\brief  Set tag values of arbitrary type on an array of entities
     *
     * Set tag values of arbitrary type on an array of entities.  Tag data
     * is passed as void*. tag_values_size specifies the size of the
     * memory pointed to by tag_values in terms of bytes. Applications may
     * use this function to set data of any type, not just iBase_BYTES.
     * However, because this function supports data of arbitrary type, in all
     * cases the size specified by tag_values_size is always in terms of
     * bytes.
     *
     * \param instance iGeom instance handle
     * \param entity_handles Entity array on which tag is being set
     * \param entity_handles_size Number of entities in array
     * \param tag_handle Tag being set on an entity
     * \param tag_values Pointer to tag data being set on entity. Note that
     *        the implicit INTERLEAVED storage order rule applies (see section
     *        ITAPS Storage Orders)
     * \param tag_values_size Size in bytes of tag data
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setArrData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         const iBase_EntityHandle* entity_handles,
                         int entity_handles_size,
                         iBase_TagHandle tag_handle,
                         const void* tag_values,
                         int tag_values_size, 
                         int *err );

    /**\brief  Set tag values of integer type on an array of entities
     *
     * Set tag values of integer type on an array of entities.
     * \param instance iGeom instance handle
     * \param entity_handles Entity array on which tag is being set
     * \param entity_handles_size Number of entities in array
     * \param tag_handle Tag being set on an entity
     * \param tag_values Pointer to tag data being set on entities
     * \param tag_values_size Size in total number of integers of tag data
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setIntArrData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            const iBase_EntityHandle* entity_handles,
                            int entity_handles_size,
                            iBase_TagHandle tag_handle,
                            const int* tag_values,
                            int tag_values_size, 
                            int *err );

    /**\brief  Set tag values of double type on an array of entities
     *
     * Set tag values of double type on an array of entities.
     * \param instance iGeom instance handle
     * \param entity_handles Entity array on which tag is being set
     * \param entity_handles_size Number of entities in array
     * \param tag_handle Tag being set on an entity
     * \param tag_values Pointer to tag data being set on entities
     * \param tag_values_size Size in total number of doubles of tag data
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setDblArrData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            const iBase_EntityHandle* entity_handles,
                            int entity_handles_size,
                            iBase_TagHandle tag_handle,
                            const double* tag_values,
                            const int tag_values_size, 
                            int *err );

    /**\brief  Set tag values of entity handle type on an array of entities
     *
     * Set tag values of entity handle type on an array of entities.
     * \param instance iGeom instance handle
     * \param entity_handles Entity array on which tag is being set
     * \param entity_handles_size Number of entities in array
     * \param tag_handle Tag being set on an entity
     * \param tag_values Pointer to tag data being set on entities
     * \param tag_values_size Size in total number of entity handles of tag 
     *        data
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setEHArrData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                           const iBase_EntityHandle* entity_handles,
                           int entity_handles_size,
                           iBase_TagHandle tag_handle,
                           const iBase_EntityHandle* tag_values,
                           int tag_values_size, 
                           int *err );

    /**\brief  Set tag values of entity set handle type on an array of entities
     *
     * Set tag values of entity set handle type on an array of entities.
     * \param instance iGeom instance handle
     * \param entity_handles Entity array on which tag is being set
     * \param entity_handles_size Number of entities in array
     * \param tag_handle Tag being set on an entity
     * \param tag_values Pointer to tag data being set on entities
     * \param tag_values_size Size in total number of entity handles of tag 
     *        data
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setESHArrData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                            const iBase_EntityHandle* entity_handles,
                            int entity_handles_size,
                            iBase_TagHandle tag_handle,
                            const iBase_EntitySetHandle* tag_values,
                            int tag_values_size, 
                            int *err );

    /**\brief  Remove a tag value from an array of entities
     *
     * Remove a tag value from an array of entities
     * \param instance iGeom instance handle
     * \param entity_handles Entity from which tag is being removed
     * \param entity_handles_size Number of entities in entity array
     * \param tag_handle Tag handle of tag being removed
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_rmvArrTag( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        const iBase_EntityHandle* entity_handles,
                        int entity_handles_size,
                        iBase_TagHandle tag_handle, 
                        int *err );

    /**\brief  Get the value of a tag of arbitrary type on an entity
     *
     * Get the value of a tag of arbitrary type on an entity.  Tag data 
     * is passed back as void*. tag_value_size specifies the size of the
     * memory pointed to by tag_value in terms of bytes. Applications may
     * use this function to get data of any type, not just iBase_BYTES.
     * However, because this function supports arbitrary type, in all
     * cases the size specified by tag_value_size is always in terms of
     * bytes.
     *
     * \param instance iGeom instance handle
     * \param entity_handle Entity on which tag is being set
     * \param tag_handle Tag being set on an entity
     * \param *tag_value Pointer to tag data array being queried
     * \param *tag_value_allocated Pointer to tag data array allocated size
     * \param *tag_value_size Pointer to occupied size in bytes of tag data
     *        array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                      iBase_EntityHandle entity_handle,
                      iBase_TagHandle tag_handle,
                      void** tag_value,
                      int *tag_value_allocated,
                      int *tag_value_size, 
                      int *err );

    /**\brief  Get the value of a tag of integer type on an entity
     *
     * Get the value of a tag of integer type on an entity.
     * \param instance iGeom instance handle
     * \param entity_handle Entity on which tag is being set
     * \param tag_handle Tag being set on an entity
     * \param *out_data Pointer to tag value returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getIntData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityHandle entity_handle,
                         iBase_TagHandle tag_handle,
                         int *out_data, 
                         int *err );

    /**\brief  Get the value of a tag of double type on an entity
     *
     * Get the value of a tag of double type on an entity.
     * \param instance iGeom instance handle
     * \param entity_handle Entity on which tag is being set
     * \param tag_handle Tag being set on an entity
     * \param *out_data Pointer to tag value returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getDblData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         /*in*/ const iBase_EntityHandle entity_handle,
                         /*in*/ const iBase_TagHandle tag_handle,
                         double *out_data,
                         int *err );

    /**\brief  Get the value of a tag of entity handle type on an entity
     *
     * Get the value of a tag of entity handle type on an entity.
     * \param instance iGeom instance handle
     * \param entity_handle Entity on which tag is being set
     * \param tag_handle Tag being set on an entity
     * \param *out_data Pointer to tag value returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getEHData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntityHandle entity_handle,
                        iBase_TagHandle tag_handle,
                        iBase_EntityHandle *out_data, 
                        int *err );

    /**\brief  Get the value of a tag of entity set handle type on an entity
     *
     * Get the value of a tag of entity set handle type on an entity.
     * \param instance iGeom instance handle
     * \param entity_handle Entity on which tag is being set
     * \param tag_handle Tag being set on an entity
     * \param *out_data Pointer to tag value returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getESHData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityHandle entity_handle,
                         iBase_TagHandle tag_handle,
                         iBase_EntitySetHandle *out_data, 
                         int *err );

    /**\brief  Set a tag value of arbitrary type on an entity
     *
     * Set a tag value of arbitrary type on an entity.  Tag data
     * is passed as void*. tag_value_size specifies the size of the
     * memory pointed to by tag_value in terms of bytes. Applications may
     * use this function to set data of any type, not just iBase_BYTES.
     * However, because this function supports data of arbitrary type, in
     * all cases the size specified by tag_value_size is always in terms
     * of bytes.
     *
     * \param instance iGeom instance handle
     * \param entity_handle Entity on which tag is being set
     * \param tag_handle Tag being set on an entity
     * \param tag_value Pointer to tag data being set on entity
     * \param tag_value_size Size in bytes of tag data
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                      iBase_EntityHandle entity_handle,
                      iBase_TagHandle tag_handle,
                      const void* tag_value,
                      int tag_value_size, 
                      int *err );

    /**\brief  Set a tag value of integer type on an entity
     *
     * Set a tag value of integer type on an entity.
     * \param instance iGeom instance handle
     * \param entity_handle Entity on which tag is being set
     * \param tag_handle Tag being set on an entity
     * \param tag_value Tag value being set on entity
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setIntData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityHandle entity_handle,
                         iBase_TagHandle tag_handle,
                         int tag_value, 
                         int *err );

    /**\brief  Set a tag value of double type on an entity
     *
     * Set a tag value of double type on an entity.
     * \param instance iGeom instance handle
     * \param entity_handle Entity on which tag is being set
     * \param tag_handle Tag being set on an entity
     * \param tag_value Tag value being set on entity
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setDblData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityHandle entity_handle,
                         iBase_TagHandle tag_handle,
                         double tag_value, 
                         int *err );

    /**\brief  Set a tag value of entity handle type on an entity
     *
     * Set a tag value of entity handle type on an entity.
     * \param instance iGeom instance handle
     * \param entity_handle Entity on which tag is being set
     * \param tag_handle Tag being set on an entity
     * \param tag_value Tag value being set on entity
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setEHData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntityHandle entity_handle,
                        iBase_TagHandle tag_handle,
                        iBase_EntityHandle tag_value, 
                        int *err );

    /**\brief  Set a tag value of entity set handle type on an entity
     *
     * Set a tag value of entity set handle type on an entity.
     * \param instance iGeom instance handle
     * \param entity_handle Entity on which tag is being set
     * \param tag_handle Tag being set on an entity
     * \param tag_value Tag value being set on entity
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_setESHData( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityHandle entity_handle,
                         iBase_TagHandle tag_handle,
                         iBase_EntitySetHandle tag_value, 
                         int *err );

    /**\brief  Get all the tags associated with a specified entity handle
     *
     * Get all the tags associated with a specified entity handle
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param *tag_handles Pointer to array of tag_handles returned from 
     *        function
     * \param *tag_handles_allocated Pointer to allocated size of tag_handles 
     *        array
     * \param *tag_handles_size Pointer to occupied size of tag_handles array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getAllTags( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                         iBase_EntityHandle entity_handle,
                         iBase_TagHandle** tag_handles,
                         int* tag_handles_allocated,
                         int* tag_handles_size, 
                         int *err );

    /**\brief  Remove a tag value from an entity
     *
     * Remove a tag value from an entity
     * \param instance iGeom instance handle
     * \param entity_handle Entity from which tag is being removed
     * \param tag_handle Tag handle of tag being removed
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_rmvTag( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                     iBase_EntityHandle entity_handle,
                     iBase_TagHandle tag_handle, 
                     int *err );

    /**\brief  Subtract contents of one entity set from another
     *
     * Subtract contents of one entity set from another
     * \param instance iGeom instance handle
     * \param entity_set_1 Entity set from which other set is being subtracted
     * \param entity_set_2 Entity set being subtracted from other set
     * \param result_entity_set Pointer to entity set returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_subtract( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                       iBase_EntitySetHandle entity_set_1,
                       iBase_EntitySetHandle entity_set_2,
                       iBase_EntitySetHandle* result_entity_set, 
                       int *err );

    /**\brief  Intersect contents of one entity set with another
     *
     * Intersect contents of one entity set with another
     * \param instance iGeom instance handle
     * \param entity_set_1 Entity set being intersected with another
     * \param entity_set_2 Entity set being intersected with another
     * \param result_entity_set Pointer to entity set returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_intersect( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                        iBase_EntitySetHandle entity_set_1,
                        iBase_EntitySetHandle entity_set_2,
                        iBase_EntitySetHandle* result_entity_set, 
                        int *err );

    /**\brief  Unite contents of one entity set with another
     *
     * Unite contents of one entity set with another
     * \param instance iGeom instance handle
     * \param entity_set_1 Entity set being united with another
     * \param entity_set_2 Entity set being united with another
     * \param result_entity_set Pointer to entity set returned from function
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_unite( iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                    iBase_EntitySetHandle entity_set_1,
                    iBase_EntitySetHandle entity_set_2,
                    iBase_EntitySetHandle* result_entity_set, 
                    int *err );

    /**\brief  Return facet information from solid modeling engine
     *
     * Return facet information from solid modeling engine
     * \param instance iGeom instance handle
     * \param entity_handle Entity being queried
     * \param dist_tolerance Tolerance guidance for faceting engine
     * \param points List of vertices in faceting of curve or surface
     * \param points_allocated Allocated size of vertex list array
     * \param points_size Occupied size of vertex list array
     * \param facets List of facets in faceting of surface
     * \param facets_allocated Allocated size of facet list array
     * \param facets_size Occupied size of facet list array
     * \param *err Pointer to error type returned from function
     */
  CGMA_IGEOM_EXPORT
  void iGeom_getFacets(iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                       iBase_EntityHandle entity,
                       double dist_tolerance,
                       double **points, int *points_allocated, int *points_size,
                       int **facets, int *facets_allocated, int *facets_size,
                       int *err);

  /* checks if a point is on a surface or a curve or a body*/
  CGMA_IGEOM_EXPORT
  void iGeom_isPositionOn(iGeom_Instance instance,<--- Skipping configuration 'CGM_FC_FUNC_' since the value of 'CGM_FC_FUNC_' is unknown. Use -D if you want to check it. You can use -U to skip it explicitly.
                          iBase_EntityHandle entity,
                          double x,
                          double y,
                          double z,
                          int *isOn); 
#ifdef __cplusplus
} /* extern "C" */
#endif

#endif