iMeshComponent: iMeshC_iMeshComponent_Impl.c

/*
 * File:          iMeshC_iMeshComponent_Impl.c
 * Symbol:        iMeshC.iMeshComponent-v0.0
 * Symbol Type:   class
 * Babel Version: 1.0.8
 * Description:   Server-side implementation for iMeshC.iMeshComponent
 * 
 * WARNING: Automatically generated; only changes within splicers preserved
 * 
 */

/*
 * DEVELOPERS ARE EXPECTED TO PROVIDE IMPLEMENTATIONS
 * FOR THE FOLLOWING METHODS BETWEEN SPLICER PAIRS.
 */

/*
 * Symbol "iMeshC.iMeshComponent" (version 0.0)
 */

#include "iMeshC_iMeshComponent_Impl.h"
#include "sidl_NotImplementedException.h"
#include "sidl_Exception.h"

/* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent._includes) */

/* Insert-UserCode-Here {iMeshC.iMeshComponent._includes} (includes and arbitrary code) */
#include <iMesh.h>

/* Bocca generated code. bocca.protected.begin(iMeshC.iMeshComponent._includes) */
#include <stdlib.h>
#include <string.h>
#include "sidl_SIDLException.h"

#define _BOCCA_CTOR_MESSAGES 0

#ifdef _BOCCA_STDERR

#define BOCCA_FPRINTF fprintf
#include <stdio.h>
#include "sidl_String.h"
#ifdef _BOCCA_CTOR_PRINT
#undef _BOCCA_CTOR_MESSAGES
#define _BOCCA_CTOR_MESSAGES 1
#endif /* _BOCCA_CTOR_PRINT */

#else /* _BOCCA_STDERR */
#define BOCCA_FPRINTF boccaPrintNothing
#endif /* _BOCCA_STDERR */

static int
boccaPrintNothing(void *v, const char * s, ...)
{
  (void)v; (void)s;
  return 0;
}
/* Bocca generated code. bocca.protected.end(iMeshC.iMeshComponent._includes) */

/* Insert-UserCode-Here {iMeshC.iMeshComponent._includes} (includes and arbitrary code) */

/* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent._includes) */

#define SIDL_IOR_MAJOR_VERSION 1
#define SIDL_IOR_MINOR_VERSION 0
/*
 * Static class initializer called exactly once before any user-defined method is dispatched
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent__load"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent__load(
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent._load) */
    /* Insert-Code-Here {iMeshC.iMeshComponent._load} (static class initializer method) */
    
    /* DO-DELETE-WHEN-IMPLEMENTING exception.begin() */
    /* 
     * This method has not been implemented.
     */
    SIDL_THROW(*_ex, sidl_NotImplementedException,     "This method has not been implemented");
  EXIT:;
    /* DO-DELETE-WHEN-IMPLEMENTING exception.end() */
    
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent._load) */
  }
}
/*
 * Class constructor called when the class is created.
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent__ctor"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent__ctor(
  /* in */ iMeshC_iMeshComponent self,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
  /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent._ctor) */

  /* Insert-UserDecl-Here {iMeshC.iMeshComponent._ctor} (constructor method) */
    
  /* bocca-default-code. User may edit or delete.begin(iMeshC.iMeshComponent._ctor) */
   struct iMeshC_iMeshComponent__data *dptr = 
       (struct iMeshC_iMeshComponent__data*)malloc(sizeof(struct iMeshC_iMeshComponent__data));
   if (dptr) {
      memset(dptr, 0, sizeof(struct iMeshC_iMeshComponent__data));
   }
   iMeshC_iMeshComponent__set_data(self, dptr);
   #if _BOCCA_CTOR_MESSAGES
     BOCCA_FPRINTF(stderr, 
        "CTOR iMeshC.iMeshComponent: %s constructed data %p in self %p\n", 
        __FUNC__, dptr, self);
   #endif /* _BOCCA_CTOR_MESSAGES */
  /* bocca-default-code. User may edit or delete.end(iMeshC.iMeshComponent._ctor) */

  /* initialize user elements of dptr here */
  /* Insert-UserCode-Here {iMeshC.iMeshComponent._ctor} (constructor method) */

  /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent._ctor) */
  }
}

/*
 * Special Class constructor called when the user wants to wrap his own private data.
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent__ctor2"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent__ctor2(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* private_data,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent._ctor2) */
    /* Insert-Code-Here {iMeshC.iMeshComponent._ctor2} (special constructor method) */
    
    /* DO-DELETE-WHEN-IMPLEMENTING exception.begin() */
    /* 
     * This method has not been implemented.
     */
    SIDL_THROW(*_ex, sidl_NotImplementedException,     "This method has not been implemented");
  EXIT:;
    /* DO-DELETE-WHEN-IMPLEMENTING exception.end() */
    
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent._ctor2) */
  }
}
/*
 * Class destructor called when the class is deleted.
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent__dtor"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent__dtor(
  /* in */ iMeshC_iMeshComponent self,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
  /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent._dtor) */

  /* deinitialize user elements of dptr here */
  /* Insert-UserCode-Here {iMeshC.iMeshComponent._dtor} (destructor method) */
    
  /* bocca-default-code. User may edit or delete.begin(iMeshC.iMeshComponent._dtor) */
   struct iMeshC_iMeshComponent__data *dptr = 
                iMeshC_iMeshComponent__get_data(self);
   if (dptr) {
      free(dptr);
      iMeshC_iMeshComponent__set_data(self, NULL);
   }
   #if _BOCCA_CTOR_MESSAGES
     BOCCA_FPRINTF(stderr, "DTOR iMeshC.iMeshComponent: %s freed data %p in self %p\n", 
                   __FUNC__, dptr, self);
   #endif /* _BOCCA_CTOR_MESSAGES */
  /* bocca-default-code. User may edit or delete.end(iMeshC.iMeshComponent._dtor) */

  /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent._dtor) */
  }
}

/*
 * Method:  boccaSetServices[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_boccaSetServices"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_boccaSetServices(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ gov_cca_Services services,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
/* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.boccaSetServices) */
/* DO-NOT-EDIT-BOCCA */
/* Bocca generated code. bocca.protected.begin(iMeshC.iMeshComponent.boccaSetServices) */
   struct iMeshC_iMeshComponent__data *pd;
   gov_cca_ComponentRelease   compRelease = NULL;
   sidl_BaseInterface throwaway_excpt = NULL; /* for use in EXIT block only. */
   int dr_services=0; /* assume releaseServices will not be called if setServices fails */
   

   gov_cca_TypeMap typeMap = NULL;
   gov_cca_Port port = NULL;

   pd = iMeshC_iMeshComponent__get_data(self);
   if (pd == NULL) {
     SIDL_THROW(*_ex, sidl_SIDLException, 
          "NULL data pointer in iMeshC.iMeshComponent boccaSetServices");
   }

   pd->d_services = services;
   gov_cca_Services_addRef(services, _ex); SIDL_CHECK(*_ex);
   dr_services=1;


  /* Create a typemap  */
   typeMap = gov_cca_Services_createTypeMap(pd->d_services, _ex); 
   SIDL_CHECK(*_ex);
   /* We must pass the exception back up; the framework is hosed and not our problem. */

  /* Cast myself to gov.cca.Port */
   port = gov_cca_Port__cast(self, _ex); SIDL_CHECK(*_ex);

   /* Provide a iMeshC.iMeshPort port with port name mesh */
   gov_cca_Services_addProvidesPort(pd->d_services,   
                                    port,               /* the implementing object */
                                    "mesh", /* the name seen by the user */
                                    "iMeshC.iMeshPort", /* sidl name of the port type. */
                                    typeMap,            /* extra properties */
                                    _ex); SIDL_CHECK(*_ex);

   gov_cca_Port_deleteRef(port, _ex); port = NULL; SIDL_CHECK(*_ex);

   gov_cca_TypeMap_deleteRef(typeMap,_ex); typeMap = NULL; SIDL_CHECK(*_ex);

   /* Cast myself to gov.cca.ComponentRelease */
   compRelease = gov_cca_ComponentRelease__cast(self, _ex); SIDL_CHECK(*_ex);
   gov_cca_Services_registerForRelease(pd->d_services, 
                                       compRelease, _ex);
   SIDL_CHECK(*_ex);
   gov_cca_ComponentRelease_deleteRef(compRelease, _ex); compRelease = NULL; 
   SIDL_CHECK(*_ex);
   return;

   /* exceptions exit through here, where we clean up memory references. */
EXIT:;
   if (dr_services != 0) { 
     gov_cca_Services_deleteRef(services, &throwaway_excpt); 
     SIDL_CLEAR(throwaway_excpt);
     services = NULL;
   }
   if (compRelease != NULL) {
     gov_cca_ComponentRelease_deleteRef(compRelease, &throwaway_excpt); 
     SIDL_CLEAR(throwaway_excpt);
     compRelease = NULL;
   }

   if (typeMap != NULL) {
     gov_cca_TypeMap_deleteRef(typeMap, &throwaway_excpt); 
     SIDL_CLEAR(throwaway_excpt);
     port = NULL;
   }
   if (port != NULL) {
     gov_cca_Port_deleteRef(port, &throwaway_excpt); 
     SIDL_CLEAR(throwaway_excpt);
     port = NULL;
   }

   return;

/* Bocca generated code. bocca.protected.end(iMeshC.iMeshComponent.boccaSetServices) */
/* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.boccaSetServices) */
  }
}

/*
 * Method:  boccaReleaseServices[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_boccaReleaseServices"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_boccaReleaseServices(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ gov_cca_Services services,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
/*  DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.boccaReleaseServices) */
/* DO-NOT-EDIT-BOCCA */
/*  Bocca generated code. bocca.protected.begin(iMeshC.iMeshComponent.boccaReleaseServices) */

   struct iMeshC_iMeshComponent__data *pd;
   sidl_BaseInterface throwaway_excpt = NULL;
   sidl_BaseInterface dummy_excpt = NULL;
   char *errMsg=NULL;
   /* our policy is to trap and optionally print all port-related messages,
      attempting to eliminate all ports. */


   /* UN-Provide a iMeshC.iMeshPort port with port name mesh */
   gov_cca_Services_removeProvidesPort(services, "mesh", 
                                       &throwaway_excpt);
   errMsg = "Error: Could not removeProvidesPort(\"mesh\")";
   iMeshC_iMeshComponent_checkException(self, throwaway_excpt, errMsg, FALSE, 
                                   &dummy_excpt);

   services = NULL;
   pd = iMeshC_iMeshComponent__get_data(self);
   if (pd == NULL) {
     SIDL_THROW(*_ex, sidl_SIDLException, 
        "NULL data pointer in iMeshC.iMeshComponent boccaSetServices");
   }
   gov_cca_Services_deleteRef(pd->d_services, _ex); 
   SIDL_CHECK(*_ex);
   pd->d_services = NULL;
   return;

EXIT:;
   return;
/*  Bocca generated code. bocca.protected.end(iMeshC.iMeshComponent.boccaReleaseServices) */
/*  DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.boccaReleaseServices)) */
  }
}

/*
 * Method:  checkException[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_checkException"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_checkException(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ sidl_BaseInterface excpt,
  /* in */ const char* msg,
  /* in */ sidl_bool fatal,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
/*  DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.checkException) */
/* DO-NOT-EDIT-BOCCA */
/*  Bocca generated code. bocca.protected.begin(iMeshC.iMeshComponent.checkException) */
#ifdef _BOCCA_STDERR
   sidl_BaseException be = NULL;
   char *etext=NULL;
#endif
   
   if (SIDL_CATCH(excpt, "sidl.BaseException")) {
#ifdef _BOCCA_STDERR
      be  = sidl_BaseException__cast(excpt, _ex); SIDL_CLEAR(*_ex);
      etext = sidl_BaseException_getNote(be, _ex); SIDL_CLEAR(*_ex);
      fprintf(stderr, "iMeshC.iMeshComponent: %s \n%s\n", msg,etext);
      sidl_String_free(etext);
      if (be != NULL) { 
        sidl_BaseException_deleteRef(be, _ex); SIDL_CLEAR(*_ex);
        be = NULL;
      }
#endif
      SIDL_CLEAR(excpt);
      if (fatal) exit(1);
   }
   return;
   
/*  Bocca generated code. bocca.protected.end(iMeshC.iMeshComponent.checkException) */
    
/*  DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.checkException) */
  }
}

/*
 *  This function should never be called, but helps babel generate better code. 
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_boccaForceUsePortInclude"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_boccaForceUsePortInclude(
  /* in */ iMeshC_iMeshComponent self,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
  /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.boccaForceUsePortInclude) */
/* DO-NOT-EDIT-BOCCA */
  /* Bocca generated code. bocca.protected.begin(iMeshC.iMeshComponent.boccaForceUsePortInclude) */
    (void)self;

  /* Bocca generated code. bocca.protected.end(iMeshC.iMeshComponent.boccaForceUsePortInclude) */
  /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.boccaForceUsePortInclude) */
  }
}

/*
 *  Starts up a component presence in the calling framework.
 * @param services the component instance's handle on the framework world.
 * Contracts concerning services and setServices:
 * 
 * The component interaction with the CCA framework
 * and Ports begins on the call to setServices by the framework.
 * 
 * This function is called exactly once for each instance created
 * by the framework.
 * 
 * The argument services will never be nil/null.
 * 
 * Those uses ports which are automatically connected by the framework
 * (so-called service-ports) may be obtained via getPort during
 * setServices.
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setServices"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setServices(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ gov_cca_Services services,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
  /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setServices) */

  /*  Insert-UserDecl-Here {iMeshC.iMeshComponent.setServices} (setServices method) */

  /* bocca-default-code. User may edit or delete.begin(iMeshC.iMeshComponent.setServices) */
    impl_iMeshC_iMeshComponent_boccaSetServices(self, services, _ex); SIDL_CHECK(*_ex);
  /* bocca-default-code. User may edit or delete.end(iMeshC.iMeshComponent.setServices) */
  
  /*  Insert-UserCode-Here {iMeshC.iMeshComponent.setServices} (setServices method) */

EXIT:;
    /* Insert additional exception cleanup here if needed. */
    return;

  /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setServices) */
  }
}

/*
 * Shuts down a component presence in the calling framework.
 * @param services the component instance's handle on the framework world.
 * Contracts concerning services and setServices:
 * 
 * This function is called exactly once for each callback registered
 * through Services.
 * 
 * The argument services will never be nil/null.
 * The argument services will always be the same as that received in
 * setServices.
 * 
 * During this call the component should release any interfaces
 * acquired by getPort().
 * 
 * During this call the component should reset to nil any stored
 * reference to services.
 * 
 * After this call, the component instance will be removed from the
 * framework. If the component instance was created by the
 * framework, it will be destroyed, not recycled, The behavior of
 * any port references obtained from this component instance and
 * stored elsewhere becomes undefined.
 * 
 * Notes for the component implementor:
 * 1) The component writer may perform blocking activities
 * within releaseServices, such as waiting for remote computations
 * to shutdown.
 * 2) It is good practice during releaseServices for the component
 * writer to remove or unregister all the ports it defined.
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_releaseServices"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_releaseServices(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ gov_cca_Services services,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
  /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.releaseServices) */

  /*  Insert-UserCode-Here {iMeshC.iMeshComponent.releaseServices} (releaseServices method) */

  /* bocca-default-code. User may edit or delete.begin(iMeshC.iMeshComponent.releaseServices) */
    impl_iMeshC_iMeshComponent_boccaReleaseServices(self, services, _ex); SIDL_CHECK(*_ex);
    return;
  /* bocca-default-code. User may edit or delete.end(iMeshC.iMeshComponent.releaseServices) */

EXIT:;
    /* Insert additional exception cleanup here if needed. */
    return;

  /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.releaseServices) */
  }
}

/*
 * Method:  newMesh[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_newMesh"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_newMesh(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ const char* options,
  /* out */ void** new_mesh,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.newMesh) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.newMesh} (newMesh method) */
   
    int err = 0;
    if (options == NULL) {
       iMesh_newMesh(NULL,new_mesh,&err,0);
    } else {
       iMesh_newMesh(options,new_mesh,&err,strlen(options));
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to allocate the mesh. Exiting with error # %d \n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }

  EXIT:; {  
    return; 
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.newMesh) */
  }
}

/*
 * Method:  deleteMesh[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_deleteMesh"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_deleteMesh(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.deleteMesh) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.deleteMesh} (deleteMesh method) */
    int err = 0;
    iMesh_dtor(mesh,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to delete mesh. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return; 
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.deleteMesh) */
  }
}

/*
 * Method:  load[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_load"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_load(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set_handle,
  /* in */ const char* name,
  /* in */ const char* options,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.load) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.load} (load method) */
    
    int err = 0;
    if (options == NULL) {
       iMesh_load(mesh,entity_set_handle,name,NULL,&err,strlen(name),0);
    } else {
       printf("filename = %s, options = %s, %d %d\n",name,options,strlen(name),strlen(options));
       iMesh_load(mesh,entity_set_handle,name,options,&err,strlen(name),
                 strlen(options));
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to load the mesh at %s. Exiting with error # %d \n",
             name,err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.load) */
  }
}

/*
 * Method:  save[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_save"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_save(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set_handle,
  /* in */ const char* name,
  /* in */ const char* options,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.save) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.save} (save method) */
    int err = 0;
    if (options == NULL) {
       iMesh_save(mesh,entity_set_handle,name,NULL,&err,strlen(name),0);
    } else {
       printf("filename = %s, options = %s, %d %d\n",name,options,strlen(name),strlen(options));
       iMesh_save(mesh,entity_set_handle,name,options,&err,strlen(name),
                 strlen(options));
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to save the mesh at %s. Exiting with error # %d \n",
             name,err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;    
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.save) */
  }
}

/*
 * Method:  getRootSet[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getRootSet"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getRootSet(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* out */ void** root_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getRootSet) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getRootSet} (getRootSet method) */
    int err = 0;
    iMesh_getRootSet(mesh,root_set,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to allocate the mesh. Exiting with error # %d \n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    
  }
  EXIT:; {
    return;  
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getRootSet) */
  }
}

/*
 * Method:  getDfltStorage[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getDfltStorage"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getDfltStorage(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* out */ int32_t* dflt_storage,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getDfltStorage) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getDfltStorage} (getDfltStorage method) */
    int err = 0;
    iMesh_getDfltStorage(mesh,dflt_storage,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get default storage order. Exiting with error # %d \n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getDfltStorage) */
  }
}

/*
 * Method:  getAllVtxCoords[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getAllVtxCoords"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getAllVtxCoords(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* out array<double> */ struct sidl_double__array** coords,
  /* out */ int32_t* coords_size,
  /* inout array<int> */ struct sidl_int__array** in_entity_set,
  /* out */ int32_t* in_entity_set_size,
  /* inout */ int32_t* storage_order,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getAllVtxCoords) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getAllVtxCoords} (getAllVtxCoords method) */
    int i, err = 0, coordsAllocated = 0, entitySetAllocated = 0, sidlSize;
    int32_t lower[1], upper[1], stride[1], *in_entity_set2;
    double *coords2;
    iMesh_getAllVtxCoords(mesh,entity_set,&coords2,&coordsAllocated,coords_size,
                         &in_entity_set2,&entitySetAllocated,
                         in_entity_set_size,storage_order,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get all vertex coordinates.");
       printf("Exiting with error # %d \n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       lower[0] = 0;
       upper[0] = *coords_size - 1;
       stride[0] = 1;
       *coords = sidl_double__array_borrow(coords2,1,lower,upper,stride);
       *in_entity_set = sidl_int__array_borrow(in_entity_set2,1,lower,
                                              upper,stride);
    }
  } 
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getAllVtxCoords) */
  }
}

/*
 * Method:  getGeometricDim[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getGeometricDim"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getGeometricDim(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* out */ int32_t* dim,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getGeometricDim) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getGeometricDim} (getGeometricDim method) */
    int err = 0;
    iMesh_getGeometricDimension(mesh,dim,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get the geometric dimension of the mesh.");
       printf("Exiting with error # %d \n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return; 
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getGeometricDim) */
  }
}

/*
 * Method:  getAdjTable[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getAdjTable"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getAdjTable(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* out array<iMeshC.AdjacencyInfo> */ struct iMeshC_AdjacencyInfo__array** 
    adjacency_table,
  /* out */ int32_t* adjacency_table_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getAdjTable) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getAdjTable} (getAdjTable method) */
    int err = 0, allocated = 0, *adTable2 = NULL;
    int lower[1], upper[1], stride[1];
    iMesh_getAdjTable(mesh,&adTable2,&allocated,adjacency_table_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get adjacency table.\n");
       printf("Exiting with error # %d \n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       lower[0] = 0;
       upper[0] = *adjacency_table_size - 1;
       stride[0] = 1;
       *adjacency_table = iMeshC_AdjacencyInfo__array_borrow(adTable2,1,
                                 lower,upper,stride);
    }
  }
  EXIT:; {
    return; 
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getAdjTable) */
  }
}

/*
 * Method:  areEHValid[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_areEHValid"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_areEHValid(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ int32_t reset,
  /* out */ int32_t* are_valid,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.areEHValid) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.areEHValid} (areEHValid method) */
    int err = 0;
    iMesh_areEHValid(mesh,reset,are_valid,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to check validity of entity handles.\n");
       printf("Exiting with error # %d \n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } 
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.areEHValid) */
  }
}

/*
 * Method:  getNumOfType[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getNumOfType"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getNumOfType(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set_handle,
  /* in */ enum iMeshC_EntityType__enum entity_type,
  /* out */ int32_t* num_type,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getNumOfType) */
    int err = 0;
    iMesh_getNumOfType(mesh,entity_set_handle,entity_type,num_type,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get the number of entities of type # %d.\n",
             entity_type);
       printf("Exiting with error # %d \n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getNumOfType) */
  }
}

/*
 * Method:  getNumOfTopo[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getNumOfTopo"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getNumOfTopo(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set_handle,
  /* in */ enum iMeshC_EntityTopology__enum entity_topology,
  /* out */ int32_t* num_topo,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getNumOfTopo) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getNumOfTopo} (getNumOfTopo method) */
    int err = 0;
    iMesh_getNumOfTopo(mesh,entity_set_handle,entity_topology,num_topo,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get the number of topologies.\n");
       printf("Exiting with error # %d \n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getNumOfTopo) */
  }
}

/*
 * Method:  getVtxCoordIndex[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getVtxCoordIndex"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getVtxCoordIndex(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ enum iMeshC_EntityType__enum requested_entity_type,
  /* in */ enum iMeshC_EntityTopology__enum requested_entity_topology,
  /* in */ enum iMeshC_EntityType__enum entity_adjacency_type,
  /* inout array<int> */ struct sidl_int__array** offset,
  /* out */ int32_t* offset_size,
  /* inout array<int> */ struct sidl_int__array** index,
  /* out */ int32_t* index_size,
  /* inout array<iMeshC.EntityTopology> */ struct 
    iMeshC_EntityTopology__array** entity_topologies,
  /* out */ int32_t* entity_topologies_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getVtxCoordIndex) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getVtxCoordIndex} (getVtxCoordIndex method) */
    int err = 0, *index2 = NULL, indexAlloc = 0, *offset2, offsetAlloc = 0;
    int entTopoAlloc = 0, *entTopo = NULL;
    int lower[1], upper[1], stride[1];
    iMesh_getVtxCoordIndex(mesh,entity_set,requested_entity_type,
                          requested_entity_topology,entity_adjacency_type,
                          &offset2,&offsetAlloc,offset_size,
                          &index2,&indexAlloc,index_size,
                          &entTopo,&entTopoAlloc, 
                          entity_topologies_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get vertex coordinate index. Exiting with error # ");
       printf("%d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       stride[0] = 1;
       lower[0] = 0;
       upper[0] = *offset_size - 1;
       *offset = sidl_int__array_borrow(offset2,1,lower,upper,stride);
       upper[0] = *index_size - 1;
       *index = sidl_int__array_borrow(index2,1,lower,upper,stride);
       upper[0] = *entity_topologies_size - 1;
       *entity_topologies = iMeshC_EntityTopology__array_borrow(entTopo,
                                 1,lower,upper,stride);
    }
    if (offsetAlloc != *offset_size) {
       printf("Number of offsets didn't agree with array size in ");
       printf("getVtxCoordIndex.\n");
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (indexAlloc != *index_size) {
       printf("Number of indices didn't agree with array size in ");
       printf("getVtxCoordIndex.\n");
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (entTopoAlloc != *entity_topologies_size) {
       printf("Number of topologies didn't agree with array size in ");
       printf("getVtxCoordIndex.\n");
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getVtxCoordIndex) */
  }
}

/*
 * Method:  getEntities[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntities"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntities(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ enum iMeshC_EntityType__enum entity_type,
  /* in */ enum iMeshC_EntityTopology__enum entity_topology,
  /* inout array<opaque> */ struct sidl_opaque__array** entity_handles,
  /* out */ int32_t* entity_handles_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntities) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntities} (getEntities method) */
    iBase_EntityHandle *entityHandles2;
    int err = 0, allocated = 0;
    int lower[1], upper[1], stride[1];
    iMesh_getEntities(mesh,entity_set,entity_type,entity_topology,
                     &entityHandles2,&allocated,entity_handles_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get entities. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       lower[0] = 0;
       upper[0] = *entity_handles_size - 1;
       stride[0] = 1;
       *entity_handles = sidl_opaque__array_borrow(entityHandles2,1,lower,
                                                  upper,stride);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntities) */
  }
}

/*
 * Method:  getVtxArrCoords[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getVtxArrCoords"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getVtxArrCoords(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* vertex_handles,
  /* in */ int32_t vertex_handles_size,
  /* inout */ int32_t* storage_order,
  /* inout array<double> */ struct sidl_double__array** coords,
  /* out */ int32_t* coords_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getVtxArrCoords) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getVtxArrCoords} (getVtxArrCoords method) */
    iBase_EntityHandle *vertexHandles2 = NULL;
    double *coords2 = NULL;
    int i = 0, err = 0, allocated = 0;
    int lower[1], upper[1], stride[1];
    // Copy input handles from SIDL array to iBase_EntityHandles array
    if (sidlStride(vertex_handles,0) == 1) {
       iMesh_getVtxArrCoords(mesh,vertex_handles->d_firstElement,
                            vertex_handles_size,storage_order,&coords2,
                            &allocated,coords_size,&err);
    } else {
       vertexHandles2 = malloc(vertex_handles_size*
                              sizeof(iBase_EntityHandle));
       for (i = 0; i < vertex_handles_size; ++i) {
           vertexHandles2[i] = sidl_opaque__array_get1(vertex_handles,i);  
       }
       iMesh_getVtxArrCoords(mesh,vertexHandles2,vertex_handles_size,
                         storage_order,&coords2,&allocated,coords_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to get entities. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       lower[0] = 0;
       upper[0] = *coords_size - 1;
       stride[0] = 1;
       *coords = sidl_double__array_borrow(coords2,1,lower,upper,stride);
    }
    if (sidlStride(vertex_handles,0) != 1) {
       free(vertexHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getVtxArrCoords) */
  }
}

/*
 * Method:  getAdjEntities[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getAdjEntities"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getAdjEntities(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ enum iMeshC_EntityType__enum entity_type_requestor,
  /* in */ enum iMeshC_EntityTopology__enum entity_topology_requestor,
  /* in */ enum iMeshC_EntityType__enum entity_type_requested,
  /* inout array<opaque> */ struct sidl_opaque__array** adj_entity_handles,
  /* out */ int32_t* adj_entity_handles_size,
  /* inout array<int> */ struct sidl_int__array** offset,
  /* out */ int32_t* offset_size,
  /* inout array<int> */ struct sidl_int__array** in_entity_set,
  /* out */ int32_t* in_entity_set_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getAdjEntities) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getAdjEntities} (getAdjEntities method) */
    iBase_EntityHandle *adjEntityHandles2 = NULL;
    int err = 0, offsetAllocated = 0, *offset2 = NULL, *inEntitySet2 = NULL;
    int inEntitySetAlloc = 0, adjEntityHandlesAlloc = 0;
    int lower[1], upper[1], stride[1];
    iMesh_getAdjEntities(mesh,entity_set,entity_type_requestor,
                        entity_topology_requestor,entity_type_requested,
                        &adjEntityHandles2,&adjEntityHandlesAlloc,
                        adj_entity_handles_size,&offset2,&offsetAllocated,
                        offset_size,&inEntitySet2,&inEntitySetAlloc,
                        in_entity_set_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get adjacent entities. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       stride[0] = 1;
       lower[0] = 0;
       upper[0] = *adj_entity_handles_size - 1;
       *adj_entity_handles = sidl_opaque__array_borrow(adjEntityHandles2,
                                                      1,lower,upper,stride);
       upper[0] = *offset_size - 1;
       *offset = sidl_int__array_borrow(offset2,1,lower,upper,stride);
       upper[0] = *in_entity_set_size - 1;
       *in_entity_set = sidl_int__array_borrow(inEntitySet2,1,lower,
                                              upper,stride);
    } 
    if (adjEntityHandlesAlloc != *adj_entity_handles_size ||
       offsetAllocated != *offset_size ||
       inEntitySetAlloc != *in_entity_set_size) {
       printf("Number of elements didn't agree with array size for an array ");
       printf("in connectivity_test.\n");
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getAdjEntities) */
  }
}

/*
 * Method:  initEntIter[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_initEntIter"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_initEntIter(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set_handle,
  /* in */ enum iMeshC_EntityType__enum requested_entity_type,
  /* in */ enum iMeshC_EntityTopology__enum requested_entity_topology,
  /* out */ void** entity_iterator,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.initEntIter) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.initEntIter} (initEntIter method) */
    int err = 0;
    iMesh_initEntIter(mesh,entity_set_handle,requested_entity_type,
                     requested_entity_topology,entity_iterator,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to initialize entity iterator. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.initEntIter) */
  }
}

/*
 * Method:  getNextEntIter[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getNextEntIter"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getNextEntIter(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_iterator,
  /* out */ void** entity_handle,
  /* out */ int32_t* at_end,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getNextEntIter) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getNextEntIter} (getNextEntIter method) */
    int err = 0;
    iMesh_getNextEntIter(mesh,entity_iterator,entity_handle,at_end,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get next entity iterator. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getNextEntIter) */
  }
}

/*
 * Method:  resetEntIter[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_resetEntIter"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_resetEntIter(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_iterator,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.resetEntIter) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.resetEntIter} (resetEntIter method) */
    int err = 0;
    iMesh_resetEntIter(mesh,entity_iterator,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to reset entity iterator. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.resetEntIter) */
  }
}

/*
 * Method:  endEntIter[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_endEntIter"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_endEntIter(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_iterator,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.endEntIter) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.endEntIter} (endEntIter method) */
    int err = 0;
    iMesh_endEntIter(mesh,entity_iterator,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to destroy entity iterator. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.endEntIter) */
  }
}

/*
 * Method:  getEntTopo[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntTopo"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntTopo(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* out */ enum iMeshC_EntityTopology__enum* ent_topo,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntTopo) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntTopo} (getEntTopo method) */
    int32_t err = 0, topo = 0;
    iMesh_getEntTopo(mesh,entity_handle,&topo,&err);
    *ent_topo = topo;
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity topology. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntTopo) */
  }
}

/*
 * Method:  getEntType[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntType"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntType(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* out */ enum iMeshC_EntityType__enum* ent_type,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntType) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntType} (getEntType method) */
    int err = 0, type = 0;
    iMesh_getEntType(mesh,entity_handle,&type,&err);
    *ent_type = type;
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity type. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntType) */
  }
}

/*
 * Method:  getVtxCoord[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getVtxCoord"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getVtxCoord(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* vertex_handle,
  /* out */ double* x,
  /* out */ double* y,
  /* out */ double* z,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getVtxCoord) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getVtxCoord} (getVtxCoord method) */
    int err = 0;
    iMesh_getVtxCoord(mesh,vertex_handle,x,y,z,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get vertex coordinates. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getVtxCoord) */
  }
}

/*
 * Method:  getEntAdj[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntAdj"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntAdj(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* in */ enum iMeshC_EntityType__enum entity_type_requested,
  /* inout array<opaque> */ struct sidl_opaque__array** adj_entity_handles,
  /* out */ int32_t* adj_entity_handles_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntAdj) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntAdj} (getEntAdj method) */
    iBase_EntityHandle *adjEntityHandles2 = NULL;
    int err = 0, alloc = 0;
    int lower[1], upper[1], stride[1];
    iMesh_getEntAdj(mesh,entity_handle,entity_type_requested,
                   &adjEntityHandles2,&alloc,adj_entity_handles_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity adjacencies. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
      lower[0] = 0;
      upper[0] = *adj_entity_handles_size - 1;
      stride[0] = 1;
      *adj_entity_handles = sidl_opaque__array_borrow(adjEntityHandles2,1,
                                                     lower,upper,stride);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntAdj) */
  }
}

/*
 * Method:  getEnt2ndAdj[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEnt2ndAdj"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEnt2ndAdj(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* in */ enum iMeshC_EntityType__enum order_adjacent_key,
  /* in */ enum iMeshC_EntityType__enum entity_type_requested,
  /* inout array<opaque> */ struct sidl_opaque__array** adj_entity_handles,
  /* out */ int32_t* adj_entity_handles_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEnt2ndAdj) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEnt2ndAdj} (getEnt2ndAdj method) */
    iBase_EntityHandle *adjEntityHandles2 = NULL;
    int err = 0, allocated = 0;
    int lower[1], upper[1], stride[1];
    iMesh_getEnt2ndAdj(mesh,entity_handle,order_adjacent_key,
                      entity_type_requested,&adjEntityHandles2,&allocated,
                      adj_entity_handles_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity second adjacencies. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
      lower[0] = 0;
      upper[0] = *adj_entity_handles_size - 1;
      stride[0] = 1;
      *adj_entity_handles = sidl_opaque__array_borrow(adjEntityHandles2,1,
                                                     lower,upper,stride);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEnt2ndAdj) */
  }
}

/*
 * Method:  initEntArrIter[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_initEntArrIter"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_initEntArrIter(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set_handle,
  /* in */ enum iMeshC_EntityType__enum requested_entity_type,
  /* in */ enum iMeshC_EntityTopology__enum requested_entity_topology,
  /* in */ int32_t requested_array_size,
  /* out */ void** entArr_iterator,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.initEntArrIter) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.initEntArrIter} (initEntArrIter method) */
    int err = 0;
    iMesh_initEntArrIter(mesh,entity_set_handle,requested_entity_type,
                        requested_entity_topology,requested_array_size,
                        entArr_iterator,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to initialize entity array iterator. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.initEntArrIter) */
  }
}

/*
 * Method:  getNextEntArrIter[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getNextEntArrIter"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getNextEntArrIter(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entArr_iterator,
  /* inout array<opaque> */ struct sidl_opaque__array** entity_handles,
  /* out */ int32_t* entity_handles_size,
  /* out */ int32_t* at_end,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getNextEntArrIter) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getNextEntArrIter} (getNextEntArrIter method) */
    iBase_EntityHandle *entityHandles2 = NULL;
    int err = 0, allocated = 0;
    int lower[1], upper[1], stride[1];
    iMesh_getNextEntArrIter(mesh,entArr_iterator,&entityHandles2,&allocated,
                           entity_handles_size,at_end,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get next entity array iterator. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
      lower[0] = 0;
      upper[0] = *entity_handles_size - 1;
      stride[0] = 1;
      *entity_handles = sidl_opaque__array_borrow(entityHandles2,1,
                                                     lower,upper,stride);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getNextEntArrIter) */
  }
}

/*
 * Method:  resetEntArrIter[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_resetEntArrIter"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_resetEntArrIter(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entArr_iterator,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.resetEntArrIter) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.resetEntArrIter} (resetEntArrIter method) */
    int err = 0;
    iMesh_resetEntArrIter(mesh,entArr_iterator,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to reset array iterator. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.resetEntArrIter) */
  }
}

/*
 * Method:  endEntArrIter[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_endEntArrIter"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_endEntArrIter(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entArr_iterator,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.endEntArrIter) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.endEntArrIter} (endEntArrIter method) */
    int err = 0;
    iMesh_endEntArrIter(mesh,entArr_iterator,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to destroy array iterator. Exiting with error # %d\n",
              err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.endEntArrIter) */
  }
}

/*
 * Method:  getEntArrTopo[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntArrTopo"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntArrTopo(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* inout array<iMeshC.EntityTopology> */ struct 
    iMeshC_EntityTopology__array** topology,
  /* out */ int32_t* topology_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntArrTopo) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntArrTopo} (getEntArrTopo method) */
    iBase_EntityHandle *entityHandles2 = NULL;
    int i = 0, err = 0, allocated = 0, *topology2 = NULL;
    int lower[1], upper[1], stride[1];
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_getEntArrTopo(mesh,entity_handles->d_firstElement,
                          entity_handles_size,&topology2,&allocated,
                          topology_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i] = sidl_opaque__array_get1(entity_handles,i);
       }
       iMesh_getEntArrTopo(mesh,entityHandles2,entity_handles_size,
                      &topology2,&allocated,topology_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity array topology. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
      lower[0] = 0;
      upper[0] = *topology_size - 1;
      stride[0] = 1;
      *topology = iMeshC_EntityTopology__array_borrow(topology2,1,lower,
                                                           upper,stride);
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntArrTopo) */
  }
}

/*
 * Method:  getEntArrType[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntArrType"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntArrType(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* inout array<iMeshC.EntityType> */ struct iMeshC_EntityType__array** type,
  /* out */ int32_t* type_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntArrType) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntArrType} (getEntArrType method) */
    iBase_EntityHandle *entityHandles2 = NULL;
    int i = 0, err = 0, allocated = 0, *type2 = NULL;
    int lower[1], upper[1], stride[1];
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_getEntArrType(mesh,entity_handles->d_firstElement,
                          entity_handles_size,&type2,&allocated,
                          type_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i] = sidl_opaque__array_get1(entity_handles,i);
       }
       iMesh_getEntArrType(mesh,entityHandles2,entity_handles_size,
                          &type2,&allocated,type_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity array type. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
      lower[0] = 0;
      upper[0] = *type_size - 1;
      stride[0] = 1;
      *type = iMeshC_EntityType__array_borrow(type2,1,lower,
                                                           upper,stride);
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntArrType) */
  }
}

/*
 * Method:  getEntArrAdj[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntArrAdj"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntArrAdj(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* in */ enum iMeshC_EntityType__enum entity_type_requested,
  /* inout array<opaque> */ struct sidl_opaque__array** adj_entity_handles,
  /* out */ int32_t* adj_entity_handles_size,
  /* inout array<int> */ struct sidl_int__array** offset,
  /* out */ int32_t* offset_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntArrAdj) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntArrAdj} (getEntArrAdj method) */
    iBase_EntityHandle *entityHandles2 = NULL, *adjEntityHandles2 = NULL;
    int i = 0, err = 0, allocated = 0, *offset2 = NULL, offsetAlloc = 0;
    int lower[1], upper[1], stride[1];
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_getEntArrAdj(mesh,entity_handles->d_firstElement,
                         entity_handles_size,entity_type_requested,
                         &adjEntityHandles2,&allocated,adj_entity_handles_size,
                         &offset2,&offsetAlloc,offset_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i] = sidl_opaque__array_get1(entity_handles,i);
       }
       iMesh_getEntArrAdj(mesh,entityHandles2,entity_handles_size,
                      entity_type_requested,&adjEntityHandles2,&allocated,
                      adj_entity_handles_size,&offset2,&offsetAlloc,
                      offset_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity array adjacencies. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
      stride[0] = 1;
      lower[0] = 0;
      upper[0] = *adj_entity_handles_size - 1;
      *adj_entity_handles = sidl_opaque__array_borrow(adjEntityHandles2,1,
                                                     lower,upper,stride);
      upper[0] = *offset_size - 1;
      *offset = sidl_int__array_borrow(offset2,1,lower,upper,stride);
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntArrAdj) */
  }
}

/*
 * Method:  getEntArr2ndAdj[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntArr2ndAdj"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntArr2ndAdj(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* in */ enum iMeshC_EntityType__enum order_adjacent_key,
  /* in */ enum iMeshC_EntityType__enum entity_type_requested,
  /* inout array<opaque> */ struct sidl_opaque__array** adj_entity_handles,
  /* out */ int32_t* adj_entity_handles_size,
  /* inout array<int> */ struct sidl_int__array** offset,
  /* out */ int32_t* offset_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntArr2ndAdj) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntArr2ndAdj} (getEntArr2ndAdj method) */
    iBase_EntityHandle *entityHandles2 = NULL, *adjEntityHandles2 = NULL;
    int i = 0, err = 0, allocated = 0, *offset2 = NULL, offsetAlloc = 0;
    int lower[1], upper[1], stride[1];
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_getEntArr2ndAdj(mesh,entity_handles->d_firstElement,
                            entity_handles_size,order_adjacent_key,
                            entity_type_requested,&adjEntityHandles2,
                            &allocated,adj_entity_handles_size,
                            &offset2,&offsetAlloc,offset_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i] = sidl_opaque__array_get1(entity_handles,i);
       }
       iMesh_getEntArr2ndAdj(mesh,entityHandles2,entity_handles_size,
                         order_adjacent_key,entity_type_requested,
                         &adjEntityHandles2,&allocated,adj_entity_handles_size,
                         &offset2,&offsetAlloc,offset_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity array second adjacencies. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       stride[0] = 1;
       lower[0] = 0;
       upper[0] = *adj_entity_handles_size - 1;
       *adj_entity_handles = sidl_opaque__array_borrow(adjEntityHandles2,1,
                                                     lower,upper,stride);
       upper[0] = *offset_size - 1;
       *offset = sidl_int__array_borrow(offset2,1,lower,upper,stride);
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntArr2ndAdj) */
  }
}

/*
 * Method:  setVtxCoords[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setVtxCoords"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setVtxCoords(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* vertex_handle,
  /* in */ double x,
  /* in */ double y,
  /* in */ double z,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setVtxCoords) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setVtxCoords} (setVtxCoords method) */
    int err = 0;
    iMesh_setVtxCoords(mesh,vertex_handle,x,y,z,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to set vertex coordinates. \
             Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setVtxCoords) */
  }
}

/*
 * Method:  createVtx[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_createVtx"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_createVtx(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ double x,
  /* in */ double y,
  /* in */ double z,
  /* out */ void** new_vertex_handle,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.createVtx) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.createVtx} (createVtx method) */
    int err = 0;
    iMesh_createVtx(mesh,x,y,z,new_vertex_handle,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to create vertex. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.createVtx) */
  }
}

/*
 * Method:  createEnt[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_createEnt"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_createEnt(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ enum iMeshC_EntityTopology__enum new_entity_topology,
  /* in array<opaque> */ struct sidl_opaque__array* lower_order_entity_handles,
  /* in */ int32_t lower_order_entity_handles_size,
  /* out */ void** new_entity_handle,
  /* out */ enum iMeshC_CreationStatus__enum* status,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.createEnt) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.createEnt} (createEnt method) */
    iBase_EntityHandle *lowerOrderEntityHandles2;
    int i ,err = 0, status2 = 0;
    int lower[1], upper[1], stride[1];
    if (sidlStride(lower_order_entity_handles,0) == 1) {
       iMesh_createEnt(mesh,new_entity_topology,
                      lower_order_entity_handles->d_firstElement,
                      lower_order_entity_handles_size,new_entity_handle,
                      &status2,&err);
    } else {
       lowerOrderEntityHandles2 = malloc(lower_order_entity_handles_size*
                                        sizeof(iBase_EntityHandle));
       for (i = 0; i < lower_order_entity_handles_size; ++i) {
           lowerOrderEntityHandles2[i] = sidl_opaque__array_get1(
                                         lower_order_entity_handles,i);
       }
       iMesh_createEnt(mesh,new_entity_topology,lowerOrderEntityHandles2,
                   lower_order_entity_handles_size,new_entity_handle,
                   &status2,&err);
    }
    *status = status2;
    if (err != iBase_SUCCESS) {
       printf("Unable to create entity. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (sidlStride(lower_order_entity_handles,0) != 1) {
       free(lowerOrderEntityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.createEnt) */
  }
}

/*
 * Method:  deleteEnt[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_deleteEnt"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_deleteEnt(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.deleteEnt) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.deleteEnt} (deleteEnt method) */
    int err = 0; 
    iMesh_deleteEnt(mesh,entity_handle,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to delete entity. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.deleteEnt) */
  }
}

/*
 * Method:  setVtxArrCoords[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setVtxArrCoords"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setVtxArrCoords(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* vertex_handles,
  /* in */ int32_t vertex_handles_size,
  /* in */ enum iMeshC_StorageOrder__enum storage_order,
  /* in array<double> */ struct sidl_double__array* new_coords,
  /* in */ int32_t new_coords_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setVtxArrCoords) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setVtxArrCoords} (setVtxArrCoords method) */
    double *coords2 = NULL;
    iBase_EntityHandle *vertexHandles2 = NULL;
    int i = 0, err = 0;
    if (sidlStride(vertex_handles,0) == 1 && sidlStride(new_coords,0) == 1) {
       iMesh_setVtxArrCoords(mesh,vertex_handles->d_firstElement,
                            vertex_handles_size,storage_order,
                            new_coords->d_firstElement,new_coords_size,&err);
    } else {
       vertexHandles2 = malloc(vertex_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < vertex_handles_size; ++i) {
           vertexHandles2[i] = sidl_opaque__array_get1(vertex_handles,i);
       }
       coords2 = malloc(new_coords_size*sizeof(double));
       for (i = 0; i < new_coords_size; ++i) {
           coords2[i] = sidl_double__array_get1(new_coords,i);
       }
       iMesh_setVtxArrCoords(mesh,vertexHandles2,vertex_handles_size,
                         storage_order,coords2,new_coords_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to set vertex array coordinates. \
              Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } 
    if (sidlStride(vertex_handles,0) != 1 || sidlStride(new_coords,0) != 1) {
       free(vertexHandles2);
       free(coords2);
    }
  } 
  EXIT:; {
    return; 
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setVtxArrCoords) */
  }
}

/*
 * Method:  createVtxArr[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_createVtxArr"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_createVtxArr(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ int32_t num_verts,
  /* in */ enum iMeshC_StorageOrder__enum storage_order,
  /* in array<double> */ struct sidl_double__array* new_coords,
  /* in */ int32_t new_coords_size,
  /* inout array<opaque> */ struct sidl_opaque__array** new_vertex_handles,
  /* out */ int32_t* new_vertex_handles_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.createVtxArr) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.createVtxArr} (createVtxArr method) */
    double *coords2;
    iBase_EntityHandle *vertexHandles = NULL;
    int i = 0, err = 0, alloc = 0, stride[1], lower[1], upper[1];
    if (sidlStride(new_coords,0) == 1) {
       iMesh_createVtxArr(mesh,num_verts,storage_order,
                         new_coords->d_firstElement,new_coords_size,
                         &vertexHandles,&alloc,new_vertex_handles_size,&err);
    } else {
       coords2 = malloc(new_coords_size*sizeof(double));
       for (i = 0; i < new_coords_size; ++i) {
           coords2[i] = sidl_double__array_get1(new_coords,i);
       }
       iMesh_createVtxArr(mesh,num_verts,storage_order,coords2,new_coords_size,
                         &vertexHandles,&alloc,new_vertex_handles_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to create vertex array coordinates. \
              Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       stride[0] = 1;
       lower[0] = 0;
       upper[0] = *new_vertex_handles_size - 1;
       *new_vertex_handles = sidl_opaque__array_borrow(vertexHandles,1,
                                                      lower,upper,stride);

    }
    if (sidlStride(new_coords,0) != 1) {
       free(coords2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.createVtxArr) */
  }
}

/*
 * Method:  createEntArr[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_createEntArr"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_createEntArr(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ enum iMeshC_EntityTopology__enum new_entity_topology,
  /* in array<opaque> */ struct sidl_opaque__array* lower_order_entity_handles,
  /* in */ int32_t lower_order_entity_handles_size,
  /* inout array<opaque> */ struct sidl_opaque__array** new_entity_handles,
  /* out */ int32_t* new_entity_handles_size,
  /* inout array<int> */ struct sidl_int__array** status,
  /* out */ int32_t* status_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.createEntArr) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.createEntArr} (createEntArr method) */
    iBase_EntityHandle *lowOrderEntityHandles2 = NULL;
    iBase_EntityHandle *newEntityHandles2 = NULL;
    int i = 0, err = 0, alloc = 0, *status2 = NULL, statusAlloc = 0;
    int lower[1], upper[1], stride[1];
    if (sidlStride(lower_order_entity_handles,0) == 1) {
       iMesh_createEntArr(mesh,new_entity_topology,
                         lower_order_entity_handles->d_firstElement,
                         lower_order_entity_handles_size,&newEntityHandles2,
                         &alloc,new_entity_handles_size,&status2,&statusAlloc,
                         status_size,&err);
    } else {
       lowOrderEntityHandles2 = malloc(lower_order_entity_handles_size*
                                      sizeof(iBase_EntityHandle));
       for (i = 0; i < lower_order_entity_handles_size; ++i) {
           lowOrderEntityHandles2[i] = sidl_opaque__array_get1(
                                    lower_order_entity_handles,i);
       }
       iMesh_createEntArr(mesh,new_entity_topology,lowOrderEntityHandles2,
                         lower_order_entity_handles_size,&newEntityHandles2,
                         &alloc,new_entity_handles_size,&status2,&statusAlloc,
                         status_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to create entity array. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       stride[0] = 1;
       lower[0] = 0;
       upper[0] = *new_entity_handles_size - 1;
       *new_entity_handles = sidl_opaque__array_borrow(newEntityHandles2,1,
                                                      lower,upper,stride);
       upper[0] = *status_size - 1;
       *status = sidl_int__array_borrow(status2,1,lower,upper,stride);
    }
    if (sidlStride(lower_order_entity_handles,0) != 1) {
       free(lowOrderEntityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.createEntArr) */
  }
}

/*
 * Method:  deleteEntArr[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_deleteEntArr"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_deleteEntArr(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.deleteEntArr) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.deleteEntArr} (deleteEntArr method) */
    iBase_EntityHandle *entityHandles2 = NULL;
    int i = 0, err = 0;
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_deleteEntArr(mesh,entity_handles->d_firstElement,
                         entity_handles_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i] = sidl_opaque__array_get1(entity_handles,i);
       }
       iMesh_deleteEntArr(mesh,entityHandles2,entity_handles_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to delete entity array. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.deleteEntArr) */
  }
}

/*
 * Method:  createTag[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_createTag"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_createTag(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ const char* tag_name,
  /* in */ int32_t number_of_values,
  /* in */ enum iMeshC_TagValueType__enum tag_type,
  /* out */ void** tag_handle,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.createTag) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.createTag} (createTag method) */
    int err = 0;
    iMesh_createTag(mesh,tag_name,number_of_values,tag_type,
                   tag_handle,&err,strlen(tag_name));
    if (err != iBase_SUCCESS) {
       printf("Unable to create tag. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.createTag) */
  }
}

/*
 * Method:  destroyTag[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_destroyTag"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_destroyTag(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* tag_handle,
  /* in */ sidl_bool forced,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.destroyTag) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.destroyTag} (destroyTag method) */
    int err = 0;
    iMesh_destroyTag(mesh,tag_handle,forced,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to destroy tag. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.destroyTag) */
  }
}

/*
 * Method:  getTagName[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getTagName"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getTagName(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* tag_handle,
  /* out */ char* tag_name,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getTagName) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getTagName} (getTagName method) */
    int err = 0, len = strlen(tag_name);
    iMesh_getTagName(mesh,tag_handle,tag_name,&err,len);
    if (err != iBase_SUCCESS) {
       printf("Unable to get tag name. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;    
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getTagName) */
  }
}

/*
 * Method:  getTagSizeValues[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getTagSizeValues"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getTagSizeValues(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* tag_handle,
  /* out */ int32_t* size_values,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getTagSizeValues) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getTagSizeValues} (getTagSizeValues method) */
    int err = 0;
    iMesh_getTagSizeValues(mesh,tag_handle,size_values,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get tag size (values). Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getTagSizeValues) */
  }
}

/*
 * Method:  getTagSizeBytes[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getTagSizeBytes"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getTagSizeBytes(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* tag_handle,
  /* out */ int32_t* size_bytes,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getTagSizeBytes) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getTagSizeBytes} (getTagSizeBytes method) */
    int err = 0;
    iMesh_getTagSizeBytes(mesh,tag_handle,size_bytes,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get tag size (bytes). Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getTagSizeBytes) */
  }
}

/*
 * Method:  getTagHandle[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getTagHandle"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getTagHandle(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ const char* tag_name,
  /* out */ void** tag_handle,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getTagHandle) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getTagHandle} (getTagHandle method) */
    int err = 0;
    iMesh_getTagHandle(mesh,tag_name,tag_handle,&err,strlen(tag_name));
    if (err != iBase_SUCCESS) {
       printf("Unable to get tag handle. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getTagHandle) */
  }
}

/*
 * Method:  getTagType[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getTagType"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getTagType(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* tag_handle,
  /* out */ enum iMeshC_TagValueType__enum* tag_data_type,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getTagType) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getTagType} (getTagType method) */
    int err = 0, type = 0;
    iMesh_getTagType(mesh,tag_handle,&type,&err);
    *tag_data_type = type;
    if (err != iBase_SUCCESS) {
       printf("Unable to get tag type. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getTagType) */
  }
}

/*
 * Method:  getData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* in */ void* tag_handle,
  /* inout array<char> */ struct sidl_char__array** tag_value,
  /* out */ int32_t* tag_value_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getData} (getData method) */
    char *tagValue2 = NULL;
    int err = 0, alloc = 0;
    int lower[1], upper[1], stride[1];
    iMesh_getData(mesh,entity_handle,tag_handle,&tagValue2,&alloc,
                 tag_value_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get data. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       lower[0] = 0;
       upper[0] = *tag_value_size - 1;
       stride[0] = 0;
       *tag_value = sidl_char__array_borrow(tagValue2,1,lower,upper,stride);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getData) */
  }
}

/*
 * Method:  getIntData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getIntData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getIntData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* in */ void* tag_handle,
  /* out */ int32_t* int_data,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getIntData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getIntData} (getIntData method) */
    int err = 0;
    iMesh_getIntData(mesh,entity_handle,tag_handle,int_data,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get IntData. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getIntData) */
  }
}

/*
 * Method:  getDblData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getDblData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getDblData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* in */ void* tag_handle,
  /* out */ double* dbl_data,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getDblData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getDblData} (getDblData method) */
    int err = 0;
    iMesh_getDblData(mesh,entity_handle,tag_handle,dbl_data,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get DblData. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getDblData) */
  }
}

/*
 * Method:  getEHData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEHData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEHData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* in */ void* tag_handle,
  /* out */ void** eh_data,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEHData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEHData} (getEHData method) */
    int err = 0;
    iMesh_getEHData(mesh,entity_handle,tag_handle,eh_data,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get EHData. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEHData) */
  }
}

/*
 * Method:  setData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* in */ void* tag_handle,
  /* in array<char> */ struct sidl_char__array* tag_value,
  /* in */ int32_t tag_value_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setData} (setData method) */
    char *tagValue2 = NULL;
    int i = 0, err = 0;
    if (sidlStride(tag_value,0) == 1) {
       iMesh_setData(mesh,entity_handle,tag_handle,tag_value->d_firstElement,
                    tag_value_size,&err);
    } else {
       tagValue2 = malloc(tag_value_size*sizeof(char));
       for (i = 0; i < tag_value_size; ++i) {
           tagValue2[i]  = sidl_char__array_get1(tag_value,i);
       } 
       iMesh_setData(mesh,entity_handle,tag_handle,tagValue2,tag_value_size,
                    &err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to set data. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (sidlStride(tag_value,0) != 1) {
       free(tagValue2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setData) */
  }
}

/*
 * Method:  setIntData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setIntData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setIntData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* in */ void* tag_handle,
  /* in */ int32_t tag_value,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setIntData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setIntData} (setIntData method) */
    int err = 0;
    iMesh_setIntData(mesh,entity_handle,tag_handle,tag_value,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to set IntData. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setIntData) */
  }
}

/*
 * Method:  setDblData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setDblData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setDblData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* in */ void* tag_handle,
  /* in */ double tag_value,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setDblData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setDblData} (setDblData method) */
    int err = 0;
    iMesh_setDblData(mesh,entity_handle,tag_handle,tag_value,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to set DblData. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setDblData) */
  }
}

/*
 * Method:  setEHData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setEHData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setEHData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* in */ void* tag_handle,
  /* in */ void* tag_value,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setEHData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setEHData} (setEHData method) */
    int err = 0;
    iMesh_setEHData(mesh,entity_handle,tag_handle,tag_value,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to set EHData. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setEHData) */
  }
}

/*
 * Method:  getAllTags[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getAllTags"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getAllTags(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* inout array<opaque> */ struct sidl_opaque__array** tag_handles,
  /* out */ int32_t* tag_handles_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getAllTags) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getAllTags} (getAllTags method) */
    iBase_EntityHandle *tagHandles2 = NULL;
    int err = 0, alloc = 0;
    int lower[1], upper[1], stride[1];
    iMesh_getAllTags(mesh,entity_handle,&tagHandles2,&alloc,tag_handles_size,
                    &err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get all tags. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       lower[0] = 0;
       upper[0] = *tag_handles_size - 1;
       stride[0] = 1;
       *tag_handles = sidl_opaque__array_borrow(tagHandles2,1,lower,upper,
                                               stride);
  }
  EXIT:;
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getAllTags) */
  }
}

/*
 * Method:  rmvTag[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_rmvTag"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_rmvTag(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* in */ void* tag_handle,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.rmvTag) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.rmvTag} (rmvTag method) */
    int err = 0;
    iMesh_rmvTag(mesh,entity_handle,tag_handle,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to remove tag. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.rmvTag) */
  }
}

/*
 * Method:  getArrData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getArrData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getArrData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* in */ void* tag_handle,
  /* inout */ char** value_array,
  /* out */ int32_t* value_array_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getArrData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getArrData} (getArrData method) */
    iBase_EntityHandle *entityHandles2 = NULL;
    int i = 0, err = 0, alloc = 0;
    int lower[1], upper[1], stride[1];
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_getArrData(mesh,entity_handles->d_firstElement,
                       entity_handles_size,tag_handle,
                       value_array,&alloc,value_array_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i]  = sidl_opaque__array_get1(entity_handles,i);
       }
       iMesh_getArrData(mesh,entityHandles2,entity_handles_size,tag_handle,
                       value_array,&alloc,value_array_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to get data by array. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getArrData) */
  }
}

/*
 * Method:  getIntArrData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getIntArrData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getIntArrData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* in */ void* tag_handle,
  /* inout array<int> */ struct sidl_int__array** value_array,
  /* out */ int32_t* value_array_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getIntArrData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getIntArrData} (getIntArrData method) */
    iBase_EntityHandle *entityHandles2 = NULL;
    int i = 0, err = 0, alloc = 0, *tagValues = NULL;
    int lower[1], upper[1], stride[1];
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_getIntArrData(mesh,entity_handles->d_firstElement,
                          entity_handles_size,tag_handle,
                          &tagValues,&alloc,value_array_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i]  = sidl_opaque__array_get1(entity_handles,i);
       } 
       iMesh_getIntArrData(mesh,entityHandles2,entity_handles_size,tag_handle,
                          &tagValues,&alloc,value_array_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to get IntData by array. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       lower[0] = 0;
       upper[0] = *value_array_size - 1;
       stride[0] = 1;
       *value_array = sidl_int__array_borrow(tagValues,1,lower,upper,stride);
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getIntArrData) */
  }
}

/*
 * Method:  getDblArrData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getDblArrData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getDblArrData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* in */ void* tag_handle,
  /* inout array<double> */ struct sidl_double__array** value_array,
  /* out */ int32_t* value_array_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getDblArrData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getDblArrData} (getDblArrData method) */
    iBase_EntityHandle *entityHandles2 = NULL;
    double *tagValues = NULL;
    int i = 0, err = 0, alloc = 0;
    int lower[1], upper[1], stride[1];
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_getDblArrData(mesh,entity_handles->d_firstElement,
                          entity_handles_size,tag_handle,
                          &tagValues,&alloc,value_array_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i]  = sidl_opaque__array_get1(entity_handles,i);
       } 
       iMesh_getDblArrData(mesh,entityHandles2,entity_handles_size,tag_handle,
                    &tagValues,&alloc,value_array_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to get DblData by array. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       lower[0] = 0;
       upper[0] = *value_array_size - 1;
       stride[0] = 1;
       *value_array = sidl_double__array_borrow(tagValues,1,lower,upper,
                                               stride);
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getDblArrData) */
  }
}

/*
 * Method:  getEHArrData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEHArrData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEHArrData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* in */ void* tag_handle,
  /* inout array<opaque> */ struct sidl_opaque__array** value_array,
  /* out */ int32_t* value_array_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEHArrData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEHArrData} (getEHArrData method) */
    iBase_EntityHandle *entityHandles2 = NULL, *tagValues = NULL;
    int i = 0, err = 0, alloc = 0;
    int lower[1], upper[1], stride[1];
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_getEHArrData(mesh,entity_handles->d_firstElement,
                         entity_handles_size,tag_handle,
                         &tagValues,&alloc,value_array_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i]  = sidl_opaque__array_get1(entity_handles,i);
       } 
       iMesh_getEHArrData(mesh,entityHandles2,entity_handles_size,tag_handle,
                         &tagValues,&alloc,value_array_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to get EHData by array. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       lower[0] = 0;
       upper[0] = *value_array_size - 1;
       stride[0] = 1;
       *value_array = sidl_opaque__array_borrow(tagValues,1,lower,upper,
                                               stride);
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEHArrData) */
  }
}

/*
 * Method:  setArrData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setArrData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setArrData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* in */ void* tag_handle,
  /* in */ const char* value_array,
  /* in */ int32_t value_array_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setArrData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setArrData} (setArrData method) */
    iBase_EntityHandle *entityHandles2 = NULL;
    int i = 0, err = 0;
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_setArrData(mesh,entity_handles->d_firstElement,
                       entity_handles_size,tag_handle,
                       value_array,value_array_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i]  = sidl_opaque__array_get1(entity_handles,i);
       } 
       iMesh_setArrData(mesh,entityHandles2,entity_handles_size,tag_handle,
                       value_array,value_array_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to set data by array. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setArrData) */
  }
}

/*
 * Method:  setIntArrData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setIntArrData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setIntArrData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* in */ void* tag_handle,
  /* in array<int> */ struct sidl_int__array* value_array,
  /* in */ int32_t value_array_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setIntArrData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setIntArrData} (setIntArrData method) */
    iBase_EntityHandle *entityHandles2 = NULL;
    int i = 0, err = 0, *tagValues = NULL;
    if (sidlStride(entity_handles,0) == 1 && sidlStride(value_array,0) == 1) {
       iMesh_setIntArrData(mesh,entity_handles->d_firstElement,
                          entity_handles_size,tag_handle,
                          value_array->d_firstElement,value_array_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i]  = sidl_opaque__array_get1(entity_handles,i);
       } 
       tagValues = malloc(value_array_size*sizeof(int));
       for (i = 0; i < value_array_size; ++i) {
           tagValues[i]  = sidl_int__array_get1(value_array,i);
       } 
       iMesh_setIntArrData(mesh,entityHandles2,entity_handles_size,tag_handle,
                          tagValues,value_array_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to set IntData by array. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (sidlStride(entity_handles,0) != 1 || sidlStride(value_array,0) != 1) {
       free(entityHandles2);
       free(tagValues);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setIntArrData) */
  }
}

/*
 * Method:  setDblArrData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setDblArrData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setDblArrData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* in */ void* tag_handle,
  /* in array<double> */ struct sidl_double__array* value_array,
  /* in */ int32_t value_array_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setDblArrData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setDblArrData} (setDblArrData method) */
    double *tagValues = NULL;
    iBase_EntityHandle *entityHandles2 = NULL;
    int i = 0, err = 0;
    if (sidlStride(entity_handles,0) == 1 && sidlStride(value_array,0) == 1) {
       iMesh_setDblArrData(mesh,entity_handles->d_firstElement,
                          entity_handles_size,tag_handle,
                          value_array->d_firstElement,value_array_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i]  = sidl_opaque__array_get1(entity_handles,i);
       } 
       tagValues = malloc(value_array_size*sizeof(double));
       for (i = 0; i < value_array_size; ++i) {
           tagValues[i]  = sidl_double__array_get1(value_array,i);
       } 
       iMesh_setDblArrData(mesh,entityHandles2,entity_handles_size,tag_handle,
                          tagValues,value_array_size,&err);
    } 
    if (err != iBase_SUCCESS) {
       printf("Unable to set DblData by array. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (sidlStride(entity_handles,0) != 1 || sidlStride(value_array,0) != 1) {
       free(entityHandles2);
       free(tagValues);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setDblArrData) */
  }
}

/*
 * Method:  setEHArrData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setEHArrData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setEHArrData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* in */ void* tag_handle,
  /* in array<opaque> */ struct sidl_opaque__array* value_array,
  /* in */ int32_t value_array_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setEHArrData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setEHArrData} (setEHArrData method) */
    iBase_EntityHandle *entityHandles2 = NULL, *tagValues = NULL;
    int i = 0, err = 0;
    if (sidlStride(entity_handles,0) == 1 && sidlStride(value_array,0) == 1) {
       iMesh_setEHArrData(mesh,entity_handles->d_firstElement,
                         entity_handles_size,tag_handle,
                         value_array->d_firstElement,value_array_size,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i]  = sidl_opaque__array_get1(entity_handles,i);
       } 
       tagValues = malloc(value_array_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < value_array_size; ++i) {
           tagValues[i]  = sidl_opaque__array_get1(value_array,i);
       } 
       iMesh_setEHArrData(mesh,entityHandles2,entity_handles_size,tag_handle,
                         tagValues,value_array_size,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to set EHData by array. Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (sidlStride(entity_handles,0) != 1 || sidlStride(value_array,0) != 1) {
       free(entityHandles2);
       free(tagValues);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setEHArrData) */
  }
}

/*
 * Method:  rmvArrTag[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_rmvArrTag"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_rmvArrTag(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* in */ void* tag_handle,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.rmvArrTag) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.rmvArrTag} (rmvArrTag method) */
    iBase_EntityHandle *entityHandles2 = NULL, *tagValues = NULL;
    int i = 0, err = 0;
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_rmvArrTag(mesh,entity_handles->d_firstElement,
                      entity_handles_size,tag_handle,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i]  = sidl_opaque__array_get1(entity_handles,i);
       } 
       iMesh_rmvArrTag(mesh,entityHandles2,entity_handles_size,tag_handle,
                      &err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to remove tags by array. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.rmvArrTag) */
  }
}

/*
 * Method:  setEntSetData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setEntSetData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setEntSetData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ void* tag_handle,
  /* in */ const char* tag_value,
  /* in */ int32_t tag_value_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setEntSetData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setEntSetData} (setEntSetData method) */
    char *tagValues = NULL;
    int i = 0, err = 0;
    /*if (sidlStride(tag_value,0) == 1) {
       iMesh_setEntSetData(mesh,entity_set,tag_handle,
                          tag_value->d_firstElement,tag_value_size,&err);
    } else {
       tagValues = malloc(tag_value_size*sizeof(char));
       for (i = 0; i < tag_value_size; ++i) {
           tagValues[i]  = sidl_char__array_get1(tag_value,i);
       } 
       iMesh_setEntSetData(mesh,entity_set,tag_handle,tagValues,tag_value_size,
                          &err);
    }*/
       iMesh_setEntSetData(mesh,entity_set,tag_handle,
                          tag_value,tag_value_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to set entity set data. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
   /* if (sidlStride(tag_value,0) != 1) {
       free(tagValues);
    }*/
  }
  EXIT:; {
    return; 
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setEntSetData) */
  }
}

/*
 * Method:  setEntSetIntData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setEntSetIntData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setEntSetIntData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ void* tag_handle,
  /* in */ int32_t tag_value,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setEntSetIntData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setEntSetIntData} (setEntSetIntData method) */
    int i = 0, err = 0;
    iMesh_setEntSetIntData(mesh,entity_set,tag_handle,tag_value,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to set entity set data. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return; 
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setEntSetIntData) */
  }
}

/*
 * Method:  setEntSetDblData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setEntSetDblData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setEntSetDblData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ void* tag_handle,
  /* in */ double tag_value,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setEntSetDblData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setEntSetDblData} (setEntSetDblData method) */
    int i = 0, err = 0;
    iMesh_setEntSetDblData(mesh,entity_set,tag_handle,tag_value,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to set entity set data. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return; 
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setEntSetDblData) */
  }
}

/*
 * Method:  setEntSetEHData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_setEntSetEHData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_setEntSetEHData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ void* tag_handle,
  /* in */ void* tag_value,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.setEntSetEHData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.setEntSetEHData} (setEntSetEHData method) */
    int i = 0, err = 0;
    iMesh_setEntSetEHData(mesh,entity_set,tag_handle,tag_value,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to set entity set data. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return; 
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.setEntSetEHData) */
  }
}

/*
 * Method:  getEntSetData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntSetData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntSetData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ void* tag_handle,
  /* inout */ char** tag_value,
  /* out */ int32_t* tag_value_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntSetData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntSetData} (getEntSetData method) */
    char *tagValue2 = NULL;
    int i = 0, err = 0, alloc = 0;
    int lower[1], upper[1], stride[1];
    //iMesh_getEntSetData(mesh,entity_set,tag_handle,&tagValue2,&alloc,
      //                 tag_value_size,&err);
    iMesh_getEntSetData(mesh,entity_set,tag_handle,tag_value,&alloc,
                       tag_value_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity set data. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } /*else {
       lower[0] = 0;
       upper[0] = *tag_value_size - 1;
       stride[0] = 1;
       *tag_value = sidl_char__array_borrow(tagValue2,1,lower,upper,stride);
    }*/
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntSetData) */
  }
}

/*
 * Method:  getEntSetIntData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntSetIntData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntSetIntData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ void* tag_handle,
  /* out */ int32_t* int_data,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntSetIntData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntSetIntData} (getEntSetIntData method) */
    int err = 0, alloc = 0;
    iMesh_getEntSetIntData(mesh,entity_set,tag_handle,int_data,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity set IntData. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntSetIntData) */
  }
}

/*
 * Method:  getEntSetDblData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntSetDblData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntSetDblData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ void* tag_handle,
  /* out */ double* dbl_data,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntSetDblData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntSetDblData} (getEntSetDblData method) */
    int err = 0, alloc = 0;
    iMesh_getEntSetDblData(mesh,entity_set,tag_handle,dbl_data,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity set DblData. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntSetDblData) */
  }
}

/*
 * Method:  getEntSetEHData[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntSetEHData"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntSetEHData(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ void* tag_handle,
  /* out */ void** eh_data,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntSetEHData) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntSetEHData} (getEntSetEHData method) */
    int err = 0, alloc = 0;
    iMesh_getEntSetEHData(mesh,entity_set,tag_handle,eh_data,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get entity set EHData. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntSetEHData) */
  }
}

/*
 * Method:  getAllEntSetTags[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getAllEntSetTags"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getAllEntSetTags(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* inout array<opaque> */ struct sidl_opaque__array** tag_handles,
  /* out */ int32_t* tag_handles_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getAllEntSetTags) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getAllEntSetTags} (getAllEntSetTags method) */
    iBase_EntityHandle *tagHandles2;
    int err = 0, alloc = 0, lower[1], upper[1], stride[1];
    iMesh_getAllEntSetTags(mesh,entity_set,&tagHandles2,&alloc,
                          tag_handles_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get all entity set data. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       lower[0] = 0;
       upper[0] = *tag_handles_size - 1;
       stride[0] = 1;
       *tag_handles = sidl_opaque__array_borrow(tagHandles2,1,lower,upper,stride);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getAllEntSetTags) */
  }
}

/*
 * Method:  rmvEntSetTag[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_rmvEntSetTag"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_rmvEntSetTag(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ void* tag_handle,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.rmvEntSetTag) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.rmvEntSetTag} (rmvEntSetTag method) */
    int err = 0;
    iMesh_rmvEntSetTag(mesh,entity_set,tag_handle,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to remove entity set tag. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.rmvEntSetTag) */
  }
}

/*
 * Method:  createEntSet[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_createEntSet"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_createEntSet(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ sidl_bool isList,
  /* out */ void** entity_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.createEntSet) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.createEntSet} (createEntSet method) */
    int err = 0;
    iMesh_createEntSet(mesh,isList,entity_set,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to create entity set. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.createEntSet) */
  }
}

/*
 * Method:  destroyEntSet[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_destroyEntSet"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_destroyEntSet(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.destroyEntSet) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.destroyEntSet} (destroyEntSet method) */
    int err = 0;
    iMesh_destroyEntSet(mesh,entity_set,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to destroy entity set. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.destroyEntSet) */
  }
}

/*
 * Method:  isList[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_isList"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_isList(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* out */ int32_t* is_list,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.isList) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.isList} (isList method) */
    int err = 0;
    iMesh_isList(mesh,entity_set,is_list,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to check list (isList). Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.isList) */
  }
}

/*
 * Method:  getNumEntSets[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getNumEntSets"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getNumEntSets(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ int32_t num_hops,
  /* out */ int32_t* num_sets,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getNumEntSets) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getNumEntSets} (getNumEntSets method) */
    int err = 0;
    iMesh_getNumEntSets(mesh,entity_set,num_hops,num_sets,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get the number of sets. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getNumEntSets) */
  }
}

/*
 * Method:  getEntSets[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getEntSets"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getEntSets(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ int32_t num_hops,
  /* inout array<opaque> */ struct sidl_opaque__array** 
    contained_entset_handles,
  /* out */ int32_t* contained_entset_handles_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getEntSets) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getEntSets} (getEntSets method) */
    iBase_EntityHandle *entitySetsHandles;
    int err = 0, alloc = 0, lower[1], upper[1], stride[1];
    iMesh_getEntSets(mesh,entity_set,num_hops,&entitySetsHandles,&alloc,
                    contained_entset_handles_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get the of sets. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
       lower[0] = 0;
       upper[0] = *contained_entset_handles_size - 1;
       stride[0] = 1;
       *contained_entset_handles = sidl_opaque__array_borrow(entitySetsHandles,
                                     1,lower,upper,stride);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getEntSets) */
  }
}

/*
 * Method:  addEntToSet[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_addEntToSet"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_addEntToSet(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* inout */ void** entity_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.addEntToSet) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.addEntToSet} (addEntToSet method) */
    int err = 0;
    iMesh_addEntToSet(mesh,entity_handle,entity_set,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to add the entity to the set. Exiting with error # %d\n",
             err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.addEntToSet) */
  }
}

/*
 * Method:  rmvEntFromSet[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_rmvEntFromSet"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_rmvEntFromSet(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_handle,
  /* inout */ void** entity_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.rmvEntFromSet) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.rmvEntFromSet} (rmvEntFromSet method) */
    int err = 0;
    iMesh_rmvEntFromSet(mesh,entity_handle,entity_set,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to delete the entity from the set. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.rmvEntFromSet) */
  }
}

/*
 * Method:  addEntArrToSet[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_addEntArrToSet"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_addEntArrToSet(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* inout */ void** entity_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.addEntArrToSet) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.addEntArrToSet} (addEntArrToSet method) */
    iBase_EntityHandle *entityHandles2 = NULL;
    int i = 0, err = 0;
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_addEntArrToSet(mesh,entity_handles->d_firstElement,
                           entity_handles_size,entity_set,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i] = sidl_opaque__array_get1(entity_handles,i);
       }
       iMesh_addEntArrToSet(mesh,entityHandles2,entity_handles_size,entity_set,
                        &err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to add the entity array to the set. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.addEntArrToSet) */
  }
}

/*
 * Method:  rmvEntArrFromSet[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_rmvEntArrFromSet"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_rmvEntArrFromSet(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in array<opaque> */ struct sidl_opaque__array* entity_handles,
  /* in */ int32_t entity_handles_size,
  /* inout */ void** entity_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.rmvEntArrFromSet) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.rmvEntArrFromSet} (rmvEntArrFromSet method) */
    iBase_EntityHandle *entityHandles2 = NULL;
    int i = 0, err = 0;
    if (sidlStride(entity_handles,0) == 1) {
       iMesh_rmvEntArrFromSet(mesh,entity_handles->d_firstElement,
                             entity_handles_size,entity_set,&err);
    } else {
       entityHandles2 = malloc(entity_handles_size*sizeof(iBase_EntityHandle));
       for (i = 0; i < entity_handles_size; ++i) {
           entityHandles2[i] = sidl_opaque__array_get1(entity_handles,i);
       }
       iMesh_rmvEntArrFromSet(mesh,entityHandles2,entity_handles_size,
                             entity_set,&err);
    }
    if (err != iBase_SUCCESS) {
       printf("Unable to remove the entity array from the set. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
    if (sidlStride(entity_handles,0) != 1) {
       free(entityHandles2);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.rmvEntArrFromSet) */
  }
}

/*
 * Method:  addEntSet[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_addEntSet"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_addEntSet(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set_to_add,
  /* inout */ void** entity_set_handle,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.addEntSet) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.addEntSet} (addEntSet method) */
    int err = 0;
    iMesh_addEntSet(mesh,entity_set_to_add,entity_set_handle,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to add the entity set. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.addEntSet) */
  }
}

/*
 * Method:  rmvEntSet[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_rmvEntSet"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_rmvEntSet(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set_to_remove,
  /* inout */ void** entity_set_handle,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.rmvEntSet) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.rmvEntSet} (rmvEntSet method) */
    int err = 0;
    iMesh_rmvEntSet(mesh,entity_set_to_remove,entity_set_handle,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to remove the entity set. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.rmvEntSet) */
  }
}

/*
 * Method:  isEntContained[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_isEntContained"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_isEntContained(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* containing_entity_set,
  /* in */ void* entity_handle,
  /* out */ int32_t* is_contained,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.isEntContained) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.isEntContained} (isEntContained method) */
    int err = 0;
    iMesh_isEntContained(mesh,containing_entity_set,entity_handle,
                        is_contained,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to check containment (isEntContained). ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.isEntContained) */
  }
}

/*
 * Method:  isEntSetContained[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_isEntSetContained"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_isEntSetContained(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* containing_entity_set,
  /* in */ void* contained_entity_set,
  /* out */ int32_t* is_contained,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.isEntSetContained) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.isEntSetContained} (isEntSetContained method) */
    int err = 0;
    iMesh_isEntSetContained(mesh,containing_entity_set,contained_entity_set,
                        is_contained,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to check set containment (isEntSetContained). ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.isEntSetContained) */
  }
}

/*
 * Method:  addPrntChld[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_addPrntChld"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_addPrntChld(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* inout */ void** parent_entity_set,
  /* inout */ void** child_entity_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.addPrntChld) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.addPrntChld} (addPrntChld method) */
    int err = 0;
    iMesh_addPrntChld(mesh,parent_entity_set,child_entity_set,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to addPrntChld. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.addPrntChld) */
  }
}

/*
 * Method:  rmvPrntChld[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_rmvPrntChld"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_rmvPrntChld(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* inout */ void** parent_entity_set,
  /* inout */ void** child_entity_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.rmvPrntChld) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.rmvPrntChld} (rmvPrntChld method) */
    int err = 0;
    iMesh_rmvPrntChld(mesh,parent_entity_set,child_entity_set,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to rmvPrntChild. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.rmvPrntChld) */
  }
}

/*
 * Method:  isChildOf[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_isChildOf"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_isChildOf(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* parent_entity_set,
  /* in */ void* child_entity_set,
  /* out */ int32_t* is_child,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.isChildOf) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.isChildOf} (isChildOf method) */
    int err = 0;
    iMesh_isChildOf(mesh,parent_entity_set,child_entity_set,is_child,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to check isChildOf. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.isChildOf) */
  }
}

/*
 * Method:  getNumChld[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getNumChld"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getNumChld(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ int32_t num_hops,
  /* out */ int32_t* num_child,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getNumChld) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getNumChld} (getNumChld method) */
    int err = 0;
    iMesh_getNumChld(mesh,entity_set,num_hops,num_child,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get the number of children. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getNumChld) */
  }
}

/*
 * Method:  getNumPrnt[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getNumPrnt"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getNumPrnt(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set,
  /* in */ int32_t num_hops,
  /* out */ int32_t* num_parent,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getNumPrnt) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getNumPrnt} (getNumPrnt method) */
    int err = 0;
    iMesh_getNumPrnt(mesh,entity_set,num_hops,num_parent,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get the number of parents. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getNumPrnt) */
  }
}

/*
 * Method:  getChldn[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getChldn"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getChldn(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* from_entity_set,
  /* in */ int32_t num_hops,
  /* inout array<opaque> */ struct sidl_opaque__array** child_handles,
  /* out */ int32_t* child_handles_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getChldn) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getChldn} (getChldn method) */
    iBase_EntityHandle *entityHandles = NULL;
    int err = 0, alloc = 0, lower[0], upper[0], stride[0];
    iMesh_getChldn(mesh,from_entity_set,num_hops,&entityHandles,&alloc,
                  child_handles_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get children. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
      lower[0] = 0;
      upper[0] = *child_handles_size - 1;
      stride[0] = 1;
      *child_handles = sidl_opaque__array_borrow(entityHandles,1,lower,upper,
                                                stride);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getChldn) */
  }
}

/*
 * Method:  getPrnts[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_getPrnts"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_getPrnts(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* from_entity_set,
  /* in */ int32_t num_hops,
  /* inout array<opaque> */ struct sidl_opaque__array** parent_handles,
  /* out */ int32_t* parent_handles_size,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.getPrnts) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.getPrnts} (getPrnts method) */
    iBase_EntityHandle *entityHandles = NULL;
    int err = 0, alloc = 0, lower[0], upper[0], stride[0];
    iMesh_getPrnts(mesh,from_entity_set,num_hops,&entityHandles,&alloc,
                  parent_handles_size,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to get parents. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    } else {
      lower[0] = 0;
      upper[0] = *parent_handles_size - 1;
      stride[0] = 1;
      *parent_handles = sidl_opaque__array_borrow(entityHandles,1,lower,upper,
                                                stride);
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.getPrnts) */
  }
}

/*
 * Method:  subtract[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_subtract"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_subtract(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set_1,
  /* in */ void* entity_set_2,
  /* out */ void** result_entity_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.subtract) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.subtract} (subtract method) */
    int err = 0;
    iMesh_subtract(mesh,entity_set_1,entity_set_2,
                  result_entity_set,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to subtract sets. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.subtract) */
  }
}

/*
 * Method:  intersect[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_intersect"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_intersect(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set_1,
  /* in */ void* entity_set_2,
  /* out */ void** result_entity_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.intersect) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.intersect} (intersect method) */
    int err = 0;
    iMesh_intersect(mesh,entity_set_1,entity_set_2,
                  result_entity_set,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to perform set intersection. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.intersect) */
  }
}

/*
 * Method:  unite[]
 */

#undef __FUNC__
#define __FUNC__ "impl_iMeshC_iMeshComponent_unite"

#ifdef __cplusplus
extern "C"
#endif
void
impl_iMeshC_iMeshComponent_unite(
  /* in */ iMeshC_iMeshComponent self,
  /* in */ void* mesh,
  /* in */ void* entity_set_1,
  /* in */ void* entity_set_2,
  /* out */ void** result_entity_set,
  /* out */ sidl_BaseInterface *_ex)
{
  *_ex = 0;
  {
    /* DO-NOT-DELETE splicer.begin(iMeshC.iMeshComponent.unite) */
    /* Insert-Code-Here {iMeshC.iMeshComponent.unite} (unite method) */
    int err = 0;
    iMesh_unite(mesh,entity_set_1,entity_set_2,
                  result_entity_set,&err);
    if (err != iBase_SUCCESS) {
       printf("Unable to unite sets. ");
       printf("Exiting with error # %d\n",err);
       SIDL_THROW(*_ex,sidl_SIDLException,"SIDL exception thrown.");
    }
  }
  EXIT:; {
    return;
    /* DO-NOT-DELETE splicer.end(iMeshC.iMeshComponent.unite) */
  }
}
/* Babel internal methods, Users should not edit below this line. */
struct gov_cca_CCAException__object* 
  impl_iMeshC_iMeshComponent_fconnect_gov_cca_CCAException(const char* url, 
  sidl_bool ar, sidl_BaseInterface *_ex) {
  return gov_cca_CCAException__connectI(url, ar, _ex);
}
struct gov_cca_CCAException__object* 
  impl_iMeshC_iMeshComponent_fcast_gov_cca_CCAException(void* bi, 
  sidl_BaseInterface* _ex) {
  return gov_cca_CCAException__cast(bi, _ex);
}
struct gov_cca_Component__object* 
  impl_iMeshC_iMeshComponent_fconnect_gov_cca_Component(const char* url, 
  sidl_bool ar, sidl_BaseInterface *_ex) {
  return gov_cca_Component__connectI(url, ar, _ex);
}
struct gov_cca_Component__object* 
  impl_iMeshC_iMeshComponent_fcast_gov_cca_Component(void* bi, 
  sidl_BaseInterface* _ex) {
  return gov_cca_Component__cast(bi, _ex);
}
struct gov_cca_ComponentRelease__object* 
  impl_iMeshC_iMeshComponent_fconnect_gov_cca_ComponentRelease(const char* url, 
  sidl_bool ar, sidl_BaseInterface *_ex) {
  return gov_cca_ComponentRelease__connectI(url, ar, _ex);
}
struct gov_cca_ComponentRelease__object* 
  impl_iMeshC_iMeshComponent_fcast_gov_cca_ComponentRelease(void* bi, 
  sidl_BaseInterface* _ex) {
  return gov_cca_ComponentRelease__cast(bi, _ex);
}
struct gov_cca_Port__object* impl_iMeshC_iMeshComponent_fconnect_gov_cca_Port(
  const char* url, sidl_bool ar, sidl_BaseInterface *_ex) {
  return gov_cca_Port__connectI(url, ar, _ex);
}
struct gov_cca_Port__object* impl_iMeshC_iMeshComponent_fcast_gov_cca_Port(
  void* bi, sidl_BaseInterface* _ex) {
  return gov_cca_Port__cast(bi, _ex);
}
struct gov_cca_Services__object* 
  impl_iMeshC_iMeshComponent_fconnect_gov_cca_Services(const char* url, 
  sidl_bool ar, sidl_BaseInterface *_ex) {
  return gov_cca_Services__connectI(url, ar, _ex);
}
struct gov_cca_Services__object* 
  impl_iMeshC_iMeshComponent_fcast_gov_cca_Services(void* bi, 
  sidl_BaseInterface* _ex) {
  return gov_cca_Services__cast(bi, _ex);
}
struct iMeshC_Error__object* impl_iMeshC_iMeshComponent_fconnect_iMeshC_Error(
  const char* url, sidl_bool ar, sidl_BaseInterface *_ex) {
  return iMeshC_Error__connectI(url, ar, _ex);
}
struct iMeshC_Error__object* impl_iMeshC_iMeshComponent_fcast_iMeshC_Error(
  void* bi, sidl_BaseInterface* _ex) {
  return iMeshC_Error__cast(bi, _ex);
}
struct iMeshC_iMeshComponent__object* 
  impl_iMeshC_iMeshComponent_fconnect_iMeshC_iMeshComponent(const char* url, 
  sidl_bool ar, sidl_BaseInterface *_ex) {
  return iMeshC_iMeshComponent__connectI(url, ar, _ex);
}
struct iMeshC_iMeshComponent__object* 
  impl_iMeshC_iMeshComponent_fcast_iMeshC_iMeshComponent(void* bi, 
  sidl_BaseInterface* _ex) {
  return iMeshC_iMeshComponent__cast(bi, _ex);
}
struct iMeshC_iMeshPort__object* 
  impl_iMeshC_iMeshComponent_fconnect_iMeshC_iMeshPort(const char* url, 
  sidl_bool ar, sidl_BaseInterface *_ex) {
  return iMeshC_iMeshPort__connectI(url, ar, _ex);
}
struct iMeshC_iMeshPort__object* 
  impl_iMeshC_iMeshComponent_fcast_iMeshC_iMeshPort(void* bi, 
  sidl_BaseInterface* _ex) {
  return iMeshC_iMeshPort__cast(bi, _ex);
}
struct sidl_BaseClass__object* 
  impl_iMeshC_iMeshComponent_fconnect_sidl_BaseClass(const char* url, sidl_bool 
  ar, sidl_BaseInterface *_ex) {
  return sidl_BaseClass__connectI(url, ar, _ex);
}
struct sidl_BaseClass__object* impl_iMeshC_iMeshComponent_fcast_sidl_BaseClass(
  void* bi, sidl_BaseInterface* _ex) {
  return sidl_BaseClass__cast(bi, _ex);
}
struct sidl_BaseInterface__object* 
  impl_iMeshC_iMeshComponent_fconnect_sidl_BaseInterface(const char* url, 
  sidl_bool ar, sidl_BaseInterface *_ex) {
  return sidl_BaseInterface__connectI(url, ar, _ex);
}
struct sidl_BaseInterface__object* 
  impl_iMeshC_iMeshComponent_fcast_sidl_BaseInterface(void* bi, 
  sidl_BaseInterface* _ex) {
  return sidl_BaseInterface__cast(bi, _ex);
}
struct sidl_ClassInfo__object* 
  impl_iMeshC_iMeshComponent_fconnect_sidl_ClassInfo(const char* url, sidl_bool 
  ar, sidl_BaseInterface *_ex) {
  return sidl_ClassInfo__connectI(url, ar, _ex);
}
struct sidl_ClassInfo__object* impl_iMeshC_iMeshComponent_fcast_sidl_ClassInfo(
  void* bi, sidl_BaseInterface* _ex) {
  return sidl_ClassInfo__cast(bi, _ex);
}
struct sidl_RuntimeException__object* 
  impl_iMeshC_iMeshComponent_fconnect_sidl_RuntimeException(const char* url, 
  sidl_bool ar, sidl_BaseInterface *_ex) {
  return sidl_RuntimeException__connectI(url, ar, _ex);
}
struct sidl_RuntimeException__object* 
  impl_iMeshC_iMeshComponent_fcast_sidl_RuntimeException(void* bi, 
  sidl_BaseInterface* _ex) {
  return sidl_RuntimeException__cast(bi, _ex);
}