iRel_Lasso.cpp

Go to the documentation of this file.

/**
 * Copyright 2006 Sandia Corporation. Under the terms of Contract
 * DE-AC04-94AL85000 with Sandia Coroporation, the U.S. Government
 * retains certain rights in this software.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 */
#include "iRel_Lasso.hpp"
 
#include "Lasso.hpp"
#include "AssocPair.hpp"
#include "ArrayManager.hpp"
 
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <vector>
 
const bool debug = false;
 
void iRel_getErrorType( iRel_Instance instance, int* error_type )
{
 if( instance == NULL )
 *error_type = iBase_FAILURE;
 else
 *error_type = LASSOI->lastErrorType;
}
 
void iRel_getDescription( iRel_Instance instance, char* descr, int descr_len )
{
 if( instance == NULL )
 {
 strcpy( descr, "iRel_getDescription: Invalid instance" );
 }
 else
 {
 unsigned int len = std::min( strlen( LASSOI->lastErrorDescription ), static_cast< size_t >( descr_len ) );
 strncpy( descr, LASSOI->lastErrorDescription, len );
 descr[len] = '\0';
 }
}
 
void iRel_create( /* in */ const char* /* options */, iRel_Instance* instance, int* err, const int options_len )
{
 if( 0 != options_len )
 {
 *instance = NULL;
 *err = iBase_NOT_SUPPORTED;
 }
 
 *instance = new Lasso();
 *err = iBase_SUCCESS;
}
 
void iRel_destroy( iRel_Instance instance, int* err )
{
 delete LASSOI;
 *err = iBase_SUCCESS;
}
 
void iRel_createPair( iRel_Instance instance,
 iBase_Instance iface1,
 const int ent_or_set1,
 const int iface_type1,
 const int irel_status1,
 iBase_Instance iface2,
 const int ent_or_set2,
 const int iface_type2,
 const int irel_status2,
 iRel_PairHandle* pair,
 int* err )
{
 AssocPair* assoc_pair = new AssocPair(
 instance, iface1, static_cast< iRel_RelationType >( ent_or_set1 ), static_cast< iRel_IfaceType >( iface_type1 ),
 static_cast< iRel_RelationStatus >( irel_status1 ), iface2, static_cast< iRel_RelationType >( ent_or_set2 ),
 static_cast< iRel_IfaceType >( iface_type2 ), static_cast< iRel_RelationStatus >( irel_status2 ) );
 LASSOI->insert_pair( assoc_pair );
 
 *pair = reinterpret_cast< iRel_PairHandle >( assoc_pair );
 RETURN( iBase_SUCCESS );
}
 
void iRel_getPairInfo( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_Instance* iface1,
 int* ent_or_set1,
 int* iface_type1,
 int* irel_status1,
 iBase_Instance* iface2,
 int* ent_or_set2,
 int* iface_type2,
 int* irel_status2,
 int* err )
{
 CHK_PAIR();
 
 *iface1 = ASSOCPAIRI->iface_instance( 0 );
 *ent_or_set1 = ASSOCPAIRI->relation_type( 0 );
 *iface_type1 = ASSOCPAIRI->iface_type( 0 );
 *irel_status1 = ASSOCPAIRI->relation_status( 0 );
 *iface2 = ASSOCPAIRI->iface_instance( 1 );
 *iface_type2 = ASSOCPAIRI->iface_type( 1 );
 *ent_or_set2 = ASSOCPAIRI->relation_type( 1 );
 *irel_status2 = ASSOCPAIRI->relation_status( 1 );
 
 RETURN( iBase_SUCCESS );
}
 
void iRel_changePairType( iRel_Instance instance, iRel_PairHandle pair, int ent_or_set1, int ent_or_set2, int* err )
{
 CHK_PAIR();
 
 CHK_ERROR( ASSOCPAIRI->change_type( 0, static_cast< iRel_RelationType >( ent_or_set1 ) ) );CHK_ERROR( ASSOCPAIRI->change_type( 1, static_cast< iRel_RelationType >( ent_or_set2 ) ) );
}
 
void iRel_changePairStatus( iRel_Instance instance, iRel_PairHandle pair, int irel_status1, int irel_status2, int* err )
{
 CHK_PAIR();
 
 CHK_ERROR( ASSOCPAIRI->change_status( 0, static_cast< iRel_RelationStatus >( irel_status1 ) ) );CHK_ERROR( ASSOCPAIRI->change_status( 1, static_cast< iRel_RelationStatus >( irel_status2 ) ) );
}
 
void iRel_destroyPair( iRel_Instance instance, iRel_PairHandle pair, int* err )
{
 CHK_PAIR();
 
 CHK_ERROR( LASSOI->erase_pair( ASSOCPAIRI ) );
}
 
void iRel_findPairs( iRel_Instance instance,
 iBase_Instance iface,
 iRel_PairHandle** pairs,
 int* pairs_allocated,
 int* pairs_size,
 int* err )
{
 std::vector< AssocPair* > tmp_pairs;
 LASSOI->find_pairs( iface, tmp_pairs );
 
 ALLOC_CHECK_ARRAY_NOFAIL( pairs, tmp_pairs.size() );
 for( size_t i = 0; i < tmp_pairs.size(); ++i )
 {
 ( *pairs )[i] = reinterpret_cast< iRel_PairHandle >( tmp_pairs[i] );
 }
 
 RETURN( iBase_SUCCESS );
}
 
void iRel_setEntEntRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle ent1,
 iBase_EntityHandle ent2,
 int* err )
{
 CHK_PAIR();CHK_ERROR( ASSOCPAIRI->set_relation( ent1, ent2 ) );
}
 
void iRel_setEntSetRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle ent1,
 iBase_EntitySetHandle set2,
 int* err )
{
 CHK_PAIR();CHK_ERROR( ASSOCPAIRI->set_relation( ent1, set2 ) );
}
 
void iRel_setSetEntRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle set1,
 iBase_EntityHandle ent2,
 int* err )
{
 CHK_PAIR();CHK_ERROR( ASSOCPAIRI->set_relation( set1, ent2 ) );
}
 
void iRel_setSetSetRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle set1,
 iBase_EntitySetHandle set2,
 int* err )
{
 CHK_PAIR();CHK_ERROR( ASSOCPAIRI->set_relation( set1, set2 ) );
}
 
void iRel_setEntArrEntArrRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle* ent_array_1,
 int num_entities1,
 iBase_EntityHandle* ent_array_2,
 int num_entities2,
 int* err )
{
 CHK_PAIR();
 
 if( num_entities1 != num_entities2 )
 ERROR( iBase_INVALID_ENTITY_COUNT, "setEntArrEntArrRelation doesn't support "
 "different #'s of entities." );
 
 int result = iBase_SUCCESS;
 char descr[200];
 for( int i = 0; i < num_entities1; i++ )
 {
 int tmp_result = ASSOCPAIRI->set_relation( ent_array_1[i], ent_array_2[i] );
 if( result == iBase_SUCCESS && tmp_result != iBase_SUCCESS )
 {
 result = tmp_result;
 iRel_getDescription( instance, descr, sizeof( descr ) );
 }
 }
 
 if( result != iBase_SUCCESS ) ERROR( result, descr );
 RETURN( iBase_SUCCESS );
}
 
void iRel_setEntArrSetArrRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle* ent_array_1,
 int num_entities1,
 iBase_EntitySetHandle* set_array_2,
 int num_sets2,
 int* err )
{
 CHK_PAIR();
 
 if( num_entities1 != num_sets2 )
 ERROR( iBase_INVALID_ENTITY_COUNT, "setEntArrSetArrRelation doesn't support "
 "different #'s of entities." );
 
 int result = iBase_SUCCESS;
 char descr[200];
 for( int i = 0; i < num_entities1; i++ )
 {
 int tmp_result = ASSOCPAIRI->set_relation( ent_array_1[i], set_array_2[i] );
 if( result == iBase_SUCCESS && tmp_result != iBase_SUCCESS )
 {
 result = tmp_result;
 iRel_getDescription( instance, descr, sizeof( descr ) );
 }
 }
 
 if( result != iBase_SUCCESS ) ERROR( result, descr );
 RETURN( iBase_SUCCESS );
}
 
void iRel_setSetArrEntArrRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle* set_array_1,
 int num_sets1,
 iBase_EntityHandle* ent_array_2,
 int num_entities2,
 int* err )
{
 CHK_PAIR();
 
 if( num_sets1 != num_entities2 )
 ERROR( iBase_INVALID_ENTITY_COUNT, "setSetArrEntArrRelation doesn't support "
 "different #'s of entities." );
 
 int result = iBase_SUCCESS;
 char descr[200];
 for( int i = 0; i < num_sets1; i++ )
 {
 int tmp_result = ASSOCPAIRI->set_relation( set_array_1[i], ent_array_2[i] );
 if( result == iBase_SUCCESS && tmp_result != iBase_SUCCESS )
 {
 result = tmp_result;
 iRel_getDescription( instance, descr, sizeof( descr ) );
 }
 }
 
 if( result != iBase_SUCCESS ) ERROR( result, descr );
 RETURN( iBase_SUCCESS );
}
 
void iRel_setSetArrSetArrRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle* set_array_1,
 int num_sets1,
 iBase_EntitySetHandle* set_array_2,
 int num_sets2,
 int* err )
{
 CHK_PAIR();
 
 if( num_sets1 != num_sets2 )
 ERROR( iBase_INVALID_ENTITY_COUNT, "setSetArrSetArrRelation doesn't support "
 "different #'s of entities." );
 
 int result = iBase_SUCCESS;
 char descr[200];
 for( int i = 0; i < num_sets1; i++ )
 {
 int tmp_result = ASSOCPAIRI->set_relation( set_array_1[i], set_array_2[i] );
 if( result == iBase_SUCCESS && tmp_result != iBase_SUCCESS )
 {
 result = tmp_result;
 iRel_getDescription( instance, descr, sizeof( descr ) );
 }
 }
 
 if( result != iBase_SUCCESS ) ERROR( result, descr );
 RETURN( iBase_SUCCESS );
}
 
void iRel_getEntEntRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle ent1,
 int switch_order,
 iBase_EntityHandle* ent2,
 int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, &ent1, 1, ent2 ) );
}
 
void iRel_getEntSetRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle ent1,
 int switch_order,
 iBase_EntitySetHandle* set2,
 int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, &ent1, 1, set2 ) );
}
 
void iRel_getSetEntRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle set1,
 int switch_order,
 iBase_EntityHandle* ent2,
 int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, &set1, 1, ent2 ) );
}
 
void iRel_getSetSetRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle set1,
 int switch_order,
 iBase_EntitySetHandle* set2,
 int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, &set1, 1, set2 ) );
}
 
void iRel_getEntSetIterRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle ent1,
 int switch_order,
 iBase_EntityIterator* entset2,
 int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, &ent1, 1, entset2 ) );
}
 
void iRel_getEntArrEntArrRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle* ent_array_1,
 int ent_array_1_size,
 int switch_order,
 iBase_EntityHandle** ent_array_2,
 int* ent_array_2_allocated,
 int* ent_array_2_size,
 int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );
 ALLOC_CHECK_ARRAY( ent_array_2, ent_array_1_size );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, ent_array_1, ent_array_1_size, *ent_array_2 ) );
 
 KEEP_ARRAY( ent_array_2 );
 RETURN( iBase_SUCCESS );
}
 
void iRel_getEntArrSetArrRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle* ent_array_1,
 int ent_array_1_size,
 int switch_order,
 iBase_EntitySetHandle** set_array_2,
 int* set_array_2_allocated,
 int* set_array_2_size,
 int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );
 ALLOC_CHECK_ARRAY( set_array_2, ent_array_1_size );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, ent_array_1, ent_array_1_size, *set_array_2 ) );
 
 KEEP_ARRAY( set_array_2 );
 RETURN( iBase_SUCCESS );
}
 
void iRel_getSetArrEntArrRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle* set_array_1,
 int set_array_1_size,
 int switch_order,
 iBase_EntityHandle** ent_array_2,
 int* ent_array_2_allocated,
 int* ent_array_2_size,
 int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );
 ALLOC_CHECK_ARRAY( ent_array_2, set_array_1_size );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, set_array_1, set_array_1_size, *ent_array_2 ) );
 
 KEEP_ARRAY( ent_array_2 );
 RETURN( iBase_SUCCESS );
}
 
void iRel_getSetArrSetArrRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle* set_array_1,
 int set_array_1_size,
 int switch_order,
 iBase_EntitySetHandle** set_array_2,
 int* set_array_2_allocated,
 int* set_array_2_size,
 int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );
 ALLOC_CHECK_ARRAY( set_array_2, set_array_1_size );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, set_array_1, set_array_1_size, *set_array_2 ) );
 
 KEEP_ARRAY( set_array_2 );
 RETURN( iBase_SUCCESS );
}
 
void iRel_getEntArrSetIterArrRelation( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle* ent_array_1,
 int ent_array_1_size,
 int switch_order,
 iBase_EntityIterator** entiter,
 int* entiter_allocated,
 int* entiter_size,
 int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );
 ;
 ALLOC_CHECK_ARRAY( entiter, ent_array_1_size );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, ent_array_1, ent_array_1_size, *entiter ) );
 
 KEEP_ARRAY( entiter );
 RETURN( iBase_SUCCESS );
}
 
void iRel_rmvEntRelation( iRel_Instance instance,
 /*in*/ iRel_PairHandle pair,
 /*in*/ iBase_EntityHandle ent,
 /*in*/ int switch_order,
 /*out*/ int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->rmv_relation( iface_no, &ent, 1 ) );
}
 
void iRel_rmvSetRelation( iRel_Instance instance,
 /*in*/ iRel_PairHandle pair,
 /*in*/ iBase_EntitySetHandle entset,
 /*in*/ int switch_order,
 /*out*/ int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->rmv_relation( iface_no, &entset, 1 ) );
}
 
void iRel_rmvEntArrRelation( iRel_Instance instance,
 /*in*/ iRel_PairHandle pair,
 /*in*/ iBase_EntityHandle* ent_array,
 /*in*/ int num_ent,
 /*in*/ int switch_order,
 /*out*/ int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->rmv_relation( iface_no, ent_array, num_ent ) );
}
 
void iRel_rmvSetArrRelation( iRel_Instance instance,
 /*in*/ iRel_PairHandle pair,
 /*in*/ iBase_EntitySetHandle* entset_array,
 /*in*/ int num_ent,
 /*in*/ int switch_order,
 /*out*/ int* err )
{
 CHK_PAIR();
 
 int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->rmv_relation( iface_no, entset_array, num_ent ) );
}
 
static int get_gids_and_dims( iRel_PairHandle pair,
 int iface_no,
 iBase_EntityHandle* ents,
 int ents_size,
 int ent_or_set,
 std::vector< int >& ents_gids,
 std::vector< int >& ents_dims )
{
 int result;
 iBase_EntitySetHandle* sets = reinterpret_cast< iBase_EntitySetHandle* >( ents );
 
 ents_gids.resize( ents_size );
 if( ent_or_set == iRel_ENTITY )
 result = ASSOCPAIRI->get_gids( iface_no, ents, ents_size, &ents_gids[0] );
 else
 result = ASSOCPAIRI->get_gids( iface_no, sets, ents_size, &ents_gids[0] );
 
 if( iBase_SUCCESS != result && iBase_TAG_NOT_FOUND != result ) return result;
 
 ents_dims.resize( ents_size, -1 );
 if( ent_or_set == iRel_ENTITY )
 {
 int* ents_dims_ptr = &ents_dims[0];
 int ents_dims_alloc = ents_dims.size(), ents_dims_size;
 result =
 ASSOCPAIRI->get_ents_dims( iface_no, ents, ents_size, &ents_dims_ptr, &ents_dims_alloc, &ents_dims_size );
 }
 else
 {
 result = ASSOCPAIRI->get_dims( iface_no, sets, ents_size, &ents_dims[0] );
 }
 
 if( iBase_SUCCESS != result && iBase_TAG_NOT_FOUND != result ) return result;
 
 return iBase_SUCCESS;
}
 
static void iRel_inferArrArrRelations( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle* ents1,
 const int ents1_size,
 int ent_or_set1,
 iBase_EntityHandle* ents2,
 const int ents2_size,
 int ent_or_set2,
 int* err )
{
 int result;
 
 std::vector< int > ents_gids, ents_dims;
 std::map< const int, iBase_EntityHandle > ents_gid_map[4];
 
 get_gids_and_dims( pair, 0, ents1, ents1_size, ent_or_set1, ents_gids, ents_dims );
 for( int i = 0; i < ents1_size; i++ )
 {
 int dim = ents_dims[i];
 if( 0 <= dim && 3 >= dim ) ents_gid_map[dim][ents_gids[i]] = ents1[i];
 }
 
 get_gids_and_dims( pair, 1, ents2, ents2_size, ent_or_set2, ents_gids, ents_dims );
 for( int i = 0; i < ents2_size; i++ )
 {
 int dim = ents_dims[i];
 
 // only check entities for which the dimension entry is in a reasonable
 // range
 if( 0 > dim || 3 < dim ) continue;
 
 // there's a match if there's an entity with that dimension with matching id
 std::map< const int, iBase_EntityHandle >::iterator iter = ents_gid_map[dim].find( ents_gids[i] );
 
 // if it matches, set the relation tags for those entities
 if( iter != ents_gid_map[dim].end() )
 {
 if( ent_or_set1 == iRel_ENTITY && ent_or_set2 == iRel_ENTITY )
 {
 result = ASSOCPAIRI->set_relation( ( *iter ).second, ents2[i] );
 }
 else if( ent_or_set1 != iRel_ENTITY && ent_or_set2 == iRel_ENTITY )
 {
 result = ASSOCPAIRI->set_relation( (iBase_EntitySetHandle)( *iter ).second, ents2[i] );
 }
 else if( ent_or_set1 == iRel_ENTITY && ent_or_set2 != iRel_ENTITY )
 {
 result = ASSOCPAIRI->set_relation( ( *iter ).second, (iBase_EntitySetHandle)ents2[i] );
 }
 else
 { // ent_or_set1 != iRel_ENTITY && ent_or_set2 != iRel_ENTITY
 result = ASSOCPAIRI->set_relation( (iBase_EntitySetHandle)( *iter ).second,
 (iBase_EntitySetHandle)ents2[i] );
 }
 
 CHK_ERROR( result );
 }
 }
 
 RETURN( iBase_SUCCESS );
}
 
void iRel_inferEntArrEntArrRelations( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle* ents1,
 const int ents1_size,
 iBase_EntityHandle* ents2,
 const int ents2_size,
 int* err )
{
 iRel_inferArrArrRelations( instance, pair, ents1, ents1_size, 0, ents2, ents2_size, 0, err );
}
 
void iRel_inferEntArrSetArrRelations( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle* ents1,
 const int ents1_size,
 iBase_EntitySetHandle* ents2,
 const int ents2_size,
 int* err )
{
 iRel_inferArrArrRelations( instance, pair, ents1, ents1_size, 0, (iBase_EntityHandle*)ents2, ents2_size, 1, err );
}
 
void iRel_inferSetArrEntArrRelations( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle* ents1,
 const int ents1_size,
 iBase_EntityHandle* ents2,
 const int ents2_size,
 int* err )
{
 iRel_inferArrArrRelations( instance, pair, (iBase_EntityHandle*)ents1, ents1_size, 1, ents2, ents2_size, 0, err );
}
 
void iRel_inferSetArrSetArrRelations( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle* ents1,
 const int ents1_size,
 int /*is_set1*/,
 iBase_EntitySetHandle* ents2,
 const int ents2_size,
 int /*is_set2*/,
 int* err )
 
{
 iRel_inferArrArrRelations( instance, pair, (iBase_EntityHandle*)ents1, ents1_size, 1, (iBase_EntityHandle*)ents2,
 ents2_size, 1, err );
}
 
void iRel_inferAllRelations( iRel_Instance instance, iRel_PairHandle pair, int* err )
{
 CHK_PAIR();
 
 // get all entities in those interfaces
 int result;
 
 iBase_EntityHandle* ents1 = NULL;
 int ents1_alloc = 0, ents1_size;
 if( ASSOCPAIRI->relation_type( 0 ) != iRel_ENTITY )
 result = ASSOCPAIRI->get_all_sets( 0, (iBase_EntitySetHandle**)&ents1, &ents1_alloc, &ents1_size );
 else
 result = ASSOCPAIRI->get_all_entities( 0, -1, &ents1, &ents1_alloc, &ents1_size );CHK_ERROR( result );
 
 iBase_EntityHandle* ents2 = NULL;
 int ents2_alloc = 0, ents2_size;
 if( ASSOCPAIRI->relation_type( 1 ) != iRel_ENTITY )
 result = ASSOCPAIRI->get_all_sets( 1, (iBase_EntitySetHandle**)&ents2, &ents2_alloc, &ents2_size );
 else
 result = ASSOCPAIRI->get_all_entities( 1, -1, &ents2, &ents2_alloc, &ents2_size );CHK_ERROR( result );
 
 iRel_inferArrArrRelations( instance, pair, ents1, ents1_size, ASSOCPAIRI->relation_type( 0 ), ents2, ents2_size,
 ASSOCPAIRI->relation_type( 1 ), &result );
 
 free( ents1 );
 free( ents2 );CHK_ERROR( result );
}
 
void iRel_inferAllRelationsAndType( iRel_Instance instance, iRel_PairHandle* /*pair*/, int* err )
{
 ERROR( iBase_NOT_SUPPORTED, "Not currently supported." );
}
 
void iRel_inferEntRelations( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle entity,
 int iface_no,
 int* err )
{
 iRel_inferEntArrRelations( instance, pair, &entity, 1, iface_no, err );
}
 
void iRel_inferSetRelations( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle entity,
 int iface_no,
 int* err )
{
 iRel_inferSetArrRelations( instance, pair, &entity, 1, iface_no, err );
}
 
static void iRel_inferArrRelations( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle* entities,
 int entities_size,
 bool is_set,
 int iface_no,
 int* err )
{
 CHK_PAIR();
 
 if( 0 > iface_no || 1 < iface_no )
 {
 ERROR( iBase_INVALID_ARGUMENT, "Interface number must be 0 or 1" );
 }
 else if( ( is_set && ASSOCPAIRI->relation_type( iface_no ) == iRel_ENTITY ) ||
 ( !is_set && ASSOCPAIRI->relation_type( iface_no ) != iRel_ENTITY ) )
 {
 ERROR( iBase_INVALID_ARGUMENT, "is_set must match entOrSet in call to "
 "inferArrRelations" );
 }
 
 // get all entities in iface2
 int result;
 iBase_EntityHandle* ents1 = entities;
 int ents1_size = entities_size;
 iBase_EntityHandle* ents2 = NULL;
 int ents2_alloc = 0, ents2_size;
 if( ASSOCPAIRI->relation_type( 1 - iface_no ) != iRel_ENTITY )
 result = ASSOCPAIRI->get_all_sets( !iface_no, (iBase_EntitySetHandle**)&ents2, &ents2_alloc, &ents2_size );
 else
 result = ASSOCPAIRI->get_all_entities( !iface_no, -1, &ents2, &ents2_alloc, &ents2_size );CHK_ERROR( result );
 
 // switch so that entity lists always go into inferArrArrRelations in
 // forward order wrt pair
 if( 1 == iface_no )
 {
 std::swap( ents1, ents2 );
 std::swap( ents1_size, ents2_size );
 }
 
 iRel_inferArrArrRelations( instance, pair, ents1, ents1_size, ASSOCPAIRI->relation_type( 0 ), ents2, ents2_size,
 ASSOCPAIRI->relation_type( 1 ), &result );
 
 free( 1 == iface_no ? ents1 : ents2 );
 
 CHK_ERROR( result );
}
 
void iRel_inferEntArrRelations( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntityHandle* entities,
 int entities_size,
 int iface_no,
 int* err )
{
 iRel_inferArrRelations( instance, pair, entities, entities_size, false, iface_no, err );
}
 
void iRel_inferSetArrRelations( iRel_Instance instance,
 iRel_PairHandle pair,
 iBase_EntitySetHandle* entities,
 int entities_size,
 int iface_no,
 int* err )
{
 iRel_inferArrRelations( instance, pair, (iBase_EntityHandle*)entities, entities_size, true, iface_no, err );
}