AssocPair.cpp

Go to the documentation of this file.

#include "AssocPair.hpp"
 
#include <cstdlib>
 
#include "Lasso.hpp"
 
#ifdef ENABLE_IGEOM
#include "GeomAssocPairSide.hpp"
#endif
#ifdef ENABLE_FBIGEOM
#include "FBGeomAssocPairSide.hpp"
#endif
#ifdef ENABLE_IMESH
#include "MeshAssocPairSide.hpp"
#endif
 
int AssocPair::currId = 0;
 
AssocPair::AssocPair( iRel_Instance p_instance,
 iBase_Instance iface0,
 iRel_RelationType ent_or_set0,
 iRel_IfaceType type0,
 iRel_RelationStatus p_status0,
 iBase_Instance iface1,
 iRel_RelationType ent_or_set1,
 iRel_IfaceType type1,
 iRel_RelationStatus p_status1 )
 : instance( p_instance )
{
 pairId = currId++;
 
 iBase_Instance ifaces[] = { iface0, iface1 };
 iRel_IfaceType types[] = { type0, type1 };
 for( int i = 0; i < 2; i++ )
 {
 switch( types[i] )
 {
#ifdef ENABLE_IGEOM
 case iRel_IGEOM_IFACE:
 relSides[i] = new GeomAssocPairSide( instance, ifaces[i], pairId );
 break;
#endif
#ifdef ENABLE_FBIGEOM
 case iRel_FBIGEOM_IFACE:
 relSides[i] = new FBGeomAssocPairSide( instance, ifaces[i], pairId );
 break;
#endif
#ifdef ENABLE_IMESH
 case iRel_IMESH_IFACE:
 relSides[i] = new MeshAssocPairSide( instance, ifaces[i], pairId );
 break;
#endif
 default:
 relSides[i] = NULL;
 }
 }
 
 entOrSet[0] = ent_or_set0;
 entOrSet[1] = ent_or_set1;
 relStatus[0] = p_status0;
 relStatus[1] = p_status1;
}
 
AssocPair::~AssocPair()
{
 for( int i = 0; i < 2; i++ )
 delete relSides[i];
}
 
int AssocPair::get_all_entities( int iface_no,
 int dimension,
 iBase_EntityHandle** entities,
 int* entities_alloc,
 int* entities_size )
{
 return relSides[iface_no]->get_all_entities( dimension, entities, entities_alloc, entities_size );
}
 
int AssocPair::get_all_sets( int iface_no, iBase_EntitySetHandle** sets, int* sets_alloc, int* sets_size )
{
 return relSides[iface_no]->get_all_sets( sets, sets_alloc, sets_size );
}
 
int AssocPair::get_entities( int iface_no,
 int dimension,
 iBase_EntitySetHandle set_handle,
 iBase_EntityHandle** entities,
 int* entities_alloc,
 int* entities_size )
{
 return relSides[iface_no]->get_entities( dimension, set_handle, entities, entities_alloc, entities_size );
}
 
int AssocPair::get_ents_dims( int iface_no,
 iBase_EntityHandle* entities,
 int entities_size,
 int** ent_types,
 int* ent_types_alloc,
 int* ent_types_size )
{
 return relSides[iface_no]->get_ents_dims( entities, entities_size, ent_types, ent_types_alloc, ent_types_size );
}
 
int AssocPair::set_relation( iBase_EntityHandle ent1, iBase_EntityHandle ent2 )
{
 if( entOrSet[0] == iRel_SET || entOrSet[1] == iRel_SET ) ERRORR( iBase_FAILURE, "Invalid relation type" );
 
 // check that if we're passing in an ent for a 'both'-type
 // assoc, there's already a set associated to the other ent
 iBase_EntityHandle tmp_ent;
 if( entOrSet[0] == iRel_BOTH && relSides[1]->get_relation_side( &ent2, 1, &tmp_ent ) != iBase_SUCCESS )
 ERRORR( iBase_FAILURE, "Couldn't find associated set on left side" );
 if( entOrSet[1] == iRel_BOTH && relSides[0]->get_relation_side( &ent1, 1, &tmp_ent ) != iBase_SUCCESS )
 ERRORR( iBase_FAILURE, "Couldn't find associated set on right side" );
 
 // set ent1 => ent2
 if( relStatus[0] == iRel_ACTIVE ) CHK_ERRORR( relSides[0]->set_relation_side( &ent1, 1, &ent2 ) );
 
 // set ent1 <= ent2
 if( relStatus[1] == iRel_ACTIVE ) CHK_ERRORR( relSides[1]->set_relation_side( &ent2, 1, &ent1 ) );
 
 RETURNR( iBase_SUCCESS );
}
 
int AssocPair::set_relation( iBase_EntityHandle ent1, iBase_EntitySetHandle set2 )
{
 if( entOrSet[0] == iRel_SET || entOrSet[1] == iRel_ENTITY ) ERRORR( iBase_FAILURE, "Invalid relation type" );
 
 // check that if we're passing in an ent for a 'both'-type
 // assoc, there's already a set associated to the other ent
 iBase_EntityHandle tmp_ent;
 if( entOrSet[0] == iRel_BOTH && relSides[1]->get_relation_side( &set2, 1, &tmp_ent ) != iBase_SUCCESS )
 ERRORR( iBase_FAILURE, "Couldn't find associated set on left side" );
 
 // set ent1 => set2
 if( relStatus[0] == iRel_ACTIVE ) CHK_ERRORR( relSides[0]->set_relation_side( &ent1, 1, &set2 ) );
 
 // set ent1 <= set2
 if( relStatus[1] == iRel_ACTIVE ) CHK_ERRORR( relSides[1]->set_relation_side( &set2, 1, &ent1 ) );
 
 // if the right side is a 'both'-type association, set the contents of set2
 // to point to ent1 as well
 if( entOrSet[1] == iRel_BOTH ) CHK_ERRORR( populate_recursive( 1, set2, ent1 ) );
 
 RETURNR( iBase_SUCCESS );
}
 
int AssocPair::set_relation( iBase_EntitySetHandle set1, iBase_EntityHandle ent2 )
{
 if( entOrSet[0] == iRel_ENTITY || entOrSet[1] == iRel_SET ) ERRORR( iBase_FAILURE, "Invalid relation type" );
 
 // check that if we're passing in an ent for a 'both'-type
 // assoc, there's already a set associated to the other ent
 iBase_EntityHandle tmp_ent;
 if( entOrSet[1] == iRel_BOTH && relSides[0]->get_relation_side( &set1, 1, &tmp_ent ) != iBase_SUCCESS )
 ERRORR( iBase_FAILURE, "Couldn't find associated set on right side" );
 
 // set set1 => ent2
 if( relStatus[0] == iRel_ACTIVE ) CHK_ERRORR( relSides[0]->set_relation_side( &set1, 1, &ent2 ) );
 
 // set ent1 <= set2
 if( relStatus[1] == iRel_ACTIVE ) CHK_ERRORR( relSides[1]->set_relation_side( &ent2, 1, &set1 ) );
 
 // if the left side is a 'both'-type association, set the contents of set1
 // to point to ent2 as well
 if( entOrSet[0] == iRel_BOTH ) CHK_ERRORR( populate_recursive( 0, set1, ent2 ) );
 
 RETURNR( iBase_SUCCESS );
}
 
int AssocPair::set_relation( iBase_EntitySetHandle set1, iBase_EntitySetHandle set2 )
{
 if( entOrSet[0] == iRel_ENTITY || entOrSet[1] == iRel_ENTITY ) ERRORR( iBase_FAILURE, "Invalid relation type" );
 
 // set set1 => set2
 if( relStatus[0] == iRel_ACTIVE ) CHK_ERRORR( relSides[0]->set_relation_side( &set1, 1, &set2 ) );
 
 // set set1 <= set2
 if( relStatus[1] == iRel_ACTIVE ) CHK_ERRORR( relSides[1]->set_relation_side( &set2, 1, &set1 ) );
 
 // if either side is a 'both'-type association, set the contents of set1
 // to point to set2 as well (and/or vice-versa)
 if( entOrSet[0] == iRel_BOTH ) CHK_ERRORR( populate_recursive( 0, set1, set2 ) );
 if( entOrSet[1] == iRel_BOTH ) CHK_ERRORR( populate_recursive( 1, set2, set1 ) );
 
 RETURNR( iBase_SUCCESS );
}
 
int AssocPair::get_relation( int iface_no,
 iBase_EntityHandle* entities,
 int num_entities,
 iBase_EntityHandle* tag_values )
{
 if( relStatus[iface_no] == iRel_NOTEXIST ) ERRORR( iBase_FAILURE, "Relation does not exist on this side" );
 if( entOrSet[!iface_no] != iRel_ENTITY ) // other iface is sets
 ERRORR( iBase_INVALID_ENTITY_HANDLE, "Expected EntitySet, got Entity" );
 
 return relSides[iface_no]->get_relation_side( entities, num_entities, tag_values );
}
 
int AssocPair::get_relation( int iface_no, iBase_EntitySetHandle* sets, int num_sets, iBase_EntityHandle* tag_values )
{
 if( relStatus[iface_no] == iRel_NOTEXIST ) ERRORR( iBase_FAILURE, "Relation does not exist on this side" );
 if( entOrSet[!iface_no] != iRel_ENTITY ) // other iface is sets
 ERRORR( iBase_INVALID_ENTITY_HANDLE, "Expected EntitySet, got Entity" );
 
 return relSides[iface_no]->get_relation_side( sets, num_sets, tag_values );
}
 
int AssocPair::get_relation( int iface_no,
 iBase_EntityHandle* entities,
 int num_entities,
 iBase_EntitySetHandle* tag_values )
{
 if( relStatus[iface_no] == iRel_NOTEXIST ) ERRORR( iBase_FAILURE, "Relation does not exist on this side" );
 if( entOrSet[!iface_no] == iRel_ENTITY ) // other iface is not sets
 ERRORR( iBase_INVALID_ENTITY_HANDLE, "Expected Entity, got EntitySet" );
 
 return relSides[iface_no]->get_relation_side( entities, num_entities, tag_values );
}
 
int AssocPair::get_relation( int iface_no,
 iBase_EntitySetHandle* sets,
 int num_sets,
 iBase_EntitySetHandle* tag_values )
{
 if( relStatus[iface_no] == iRel_NOTEXIST ) ERRORR( iBase_FAILURE, "Relation does not exist on this side" );
 if( entOrSet[!iface_no] == iRel_ENTITY ) // other iface is not sets
 ERRORR( iBase_INVALID_ENTITY_HANDLE, "Expected Entity, got EntitySet" );
 
 return relSides[iface_no]->get_relation_side( sets, num_sets, tag_values );
}
 
int AssocPair::get_relation( int iface_no,
 iBase_EntityHandle* entities,
 int num_entities,
 iBase_EntityIterator* tag_values )
{
 std::vector< iBase_EntitySetHandle > sets( num_entities );CHK_ERRORR( get_relation( iface_no, entities, num_entities, &sets[0] ) );
 
 for( int i = 0; i < num_entities; i++ )
 CHK_ERRORR( relSides[i]->get_iterator( sets[i], &tag_values[i] ) );
 
 RETURNR( iBase_SUCCESS );
}
 
int AssocPair::get_relation( int iface_no, iBase_EntitySetHandle* sets, int num_sets, iBase_EntityIterator* tag_values )
{
 std::vector< iBase_EntitySetHandle > sets2( num_sets );CHK_ERRORR( get_relation( iface_no, sets, num_sets, &sets2[0] ) );
 
 for( int i = 0; i < num_sets; i++ )
 CHK_ERRORR( relSides[iface_no]->get_iterator( sets2[i], &tag_values[i] ) );
 
 RETURNR( iBase_SUCCESS );
}
 
int AssocPair::rmv_relation( int iface_no, iBase_EntityHandle* entities, int num_entities )
{
 if( relStatus[iface_no] == iRel_NOTEXIST ) ERRORR( iBase_FAILURE, "Relation does not exist on this side" );
 
 // TODO: handle "both" case
 
 // Remove the opposite side first
 if( relStatus[!iface_no] == iRel_ACTIVE )
 {
 if( entOrSet[!iface_no] == iRel_ENTITY )
 {
 std::vector< iBase_EntityHandle > other_entities( num_entities );CHK_ERRORR( get_relation( iface_no, entities, num_entities, &other_entities[0] ) );CHK_ERRORR( relSides[!iface_no]->rmv_relation_side( &other_entities[0], num_entities ) );
 }
 else
 {
 std::vector< iBase_EntitySetHandle > other_sets( num_entities );CHK_ERRORR( get_relation( iface_no, entities, num_entities, &other_sets[0] ) );CHK_ERRORR( relSides[!iface_no]->rmv_relation_side( &other_sets[0], num_entities ) );
 }
 }
 
 return relSides[iface_no]->rmv_relation_side( entities, num_entities );
}
 
int AssocPair::rmv_relation( int iface_no, iBase_EntitySetHandle* sets, int num_sets )
{
 if( relStatus[iface_no] == iRel_NOTEXIST ) ERRORR( iBase_FAILURE, "Relation does not exist on this side" );
 
 // TODO: handle "both" case
 
 // Remove the opposite side first
 if( relStatus[!iface_no] == iRel_ACTIVE )
 {
 if( entOrSet[!iface_no] == iRel_ENTITY )
 {
 std::vector< iBase_EntityHandle > other_entities( num_sets );CHK_ERRORR( get_relation( iface_no, sets, num_sets, &other_entities[0] ) );CHK_ERRORR( relSides[!iface_no]->rmv_relation_side( &other_entities[0], num_sets ) );
 }
 else
 {
 std::vector< iBase_EntitySetHandle > other_sets( num_sets );CHK_ERRORR( get_relation( iface_no, sets, num_sets, &other_sets[0] ) );CHK_ERRORR( relSides[!iface_no]->rmv_relation_side( &other_sets[0], num_sets ) );
 }
 }
 
 return relSides[iface_no]->rmv_relation_side( sets, num_sets );
}
 
int AssocPair::get_gids( int iface_no, iBase_EntityHandle* entities, int num_entities, int* tag_values )
{
 return relSides[iface_no]->get_gids( entities, num_entities, tag_values );
}
 
int AssocPair::get_gids( int iface_no, iBase_EntitySetHandle* sets, int num_sets, int* tag_values )
{
 return relSides[iface_no]->get_gids( sets, num_sets, tag_values );
}
 
int AssocPair::get_dims( int iface_no, iBase_EntityHandle* entities, int num_entities, int* tag_values )
{
 return relSides[iface_no]->get_dims( entities, num_entities, tag_values );
}
 
int AssocPair::get_dims( int iface_no, iBase_EntitySetHandle* sets, int num_sets, int* tag_values )
{
 return relSides[iface_no]->get_dims( sets, num_sets, tag_values );
}
 
int AssocPair::change_type( int iface_no, iRel_RelationType type )
{
 if( entOrSet[iface_no] == type ) RETURNR( iBase_SUCCESS );
 if( entOrSet[iface_no] == iRel_ENTITY || type == iRel_ENTITY )
 ERRORR( iBase_FAILURE, "Can only change type from \"set\" to \"both\", or "
 "vice-versa" );
 
 entOrSet[iface_no] = type;
 if( relStatus[iface_no] != iRel_ACTIVE ) RETURNR( iBase_SUCCESS );
 
 iBase_EntitySetHandle* sets = NULL;
 int set_alloc = 0, set_size;CHK_ERRORR( relSides[iface_no]->get_related_sets( &sets, &set_alloc, &set_size ) );
 if( type == iRel_BOTH )
 {
 if( entOrSet[!iface_no] == iRel_ENTITY )
 {
 std::vector< iBase_EntityHandle > related_ents( set_size );CHK_ERRORR( relSides[iface_no]->get_relation_side( sets, set_size, &related_ents[0] ) );
 
 for( int i = 0; i < set_size; i++ )
 CHK_ERRORR( populate_recursive( iface_no, sets[i], related_ents[i] ) );
 }
 else
 {
 std::vector< iBase_EntitySetHandle > related_sets( set_size );CHK_ERRORR( relSides[iface_no]->get_relation_side( sets, set_size, &related_sets[0] ) );
 
 for( int i = 0; i < set_size; i++ )
 CHK_ERRORR( populate_recursive( iface_no, sets[i], related_sets[i] ) );
 }
 }
 else if( type == iRel_SET )
 {
 for( int i = 0; i < set_size; i++ )
 CHK_ERRORR( unpopulate_recursive( iface_no, sets[i] ) );
 }
 
 free( sets );
 RETURNR( iBase_SUCCESS );
}
 
int AssocPair::change_status( int iface_no, iRel_RelationStatus status )
{
 if( relStatus[iface_no] == status ) RETURNR( iBase_SUCCESS );
 
 relStatus[iface_no] = status;
 
 if( status == iRel_NOTEXIST )
 {
 // Destroy the assoc tag
 CHK_ERRORR( relSides[iface_no]->destroy_relation_side() );
 }
 else if( status == iRel_INACTIVE )
 {
 // Create the assoc tag
 CHK_ERRORR( relSides[iface_no]->create_relation_side() );
 }
 // Update the assoc tag
 else if( status == iRel_ACTIVE )
 {
 CHK_ERRORR( relSides[iface_no]->destroy_relation_side() );CHK_ERRORR( relSides[iface_no]->create_relation_side() );
 
 if( entOrSet[!iface_no] == iRel_ENTITY )
 {
 iBase_EntityHandle* entities = NULL;
 int ent_alloc = 0, ent_size;
 
 CHK_ERRORR( relSides[!iface_no]->get_related_ents( &entities, &ent_alloc, &ent_size ) );
 if( entOrSet[iface_no] == iRel_ENTITY )
 {
 std::vector< iBase_EntityHandle > related_ents( ent_size );
 int result = relSides[!iface_no]->get_relation_side( entities, ent_size, &related_ents[0] );
 
 if( result == iBase_SUCCESS )
 {
 if( iface_no == 0 )
 for( int i = 0; i < ent_size; i++ )
 CHK_ERRORR( set_relation( related_ents[i], entities[i] ) );
 else
 for( int i = 0; i < ent_size; i++ )
 CHK_ERRORR( set_relation( entities[i], related_ents[i] ) );
 }
 }
 else
 {
 std::vector< iBase_EntitySetHandle > related_sets( ent_size );
 int result = relSides[!iface_no]->get_relation_side( entities, ent_size, &related_sets[0] );
 
 if( result == iBase_SUCCESS )
 {
 if( iface_no == 0 )
 for( int i = 0; i < ent_size; i++ )
 CHK_ERRORR( set_relation( related_sets[i], entities[i] ) );
 else
 for( int i = 0; i < ent_size; i++ )
 CHK_ERRORR( set_relation( entities[i], related_sets[i] ) );
 }
 }
 
 free( entities );
 }
 else
 {
 iBase_EntitySetHandle* sets = NULL;
 int set_alloc = 0, set_size;
 
 CHK_ERRORR( relSides[!iface_no]->get_related_sets( &sets, &set_alloc, &set_size ) );
 if( entOrSet[iface_no] == iRel_ENTITY )
 {
 std::vector< iBase_EntityHandle > related_ents( set_size );
 int result = relSides[!iface_no]->get_relation_side( sets, set_size, &related_ents[0] );
 
 if( result == iBase_SUCCESS )
 {
 if( iface_no == 0 )
 for( int i = 0; i < set_size; i++ )
 CHK_ERRORR( set_relation( related_ents[i], sets[i] ) );
 else
 for( int i = 0; i < set_size; i++ )
 CHK_ERRORR( set_relation( sets[i], related_ents[i] ) );
 }
 }
 else
 {
 std::vector< iBase_EntitySetHandle > related_sets( set_size );
 int result = relSides[!iface_no]->get_relation_side( sets, set_size, &related_sets[0] );
 
 if( result == iBase_SUCCESS )
 {
 if( iface_no == 0 )
 for( int i = 0; i < set_size; i++ )
 CHK_ERRORR( set_relation( related_sets[i], sets[i] ) );
 else
 for( int i = 0; i < set_size; i++ )
 CHK_ERRORR( set_relation( sets[i], related_sets[i] ) );
 }
 }
 
 free( sets );
 }
 }
 else
 {
 ERRORR( iBase_INVALID_ARGUMENT, "Invalid argument for relation status" );
 }
 
 RETURNR( iBase_SUCCESS );
}
 
bool AssocPair::equivalent( iBase_Instance iface0, iBase_Instance iface1, bool* order_switched )
{
 if( iface0 == relSides[0]->instance() && iface1 == relSides[1]->instance() )
 {
 if( order_switched ) *order_switched = false;
 return true;
 }
 else if( iface0 == relSides[1]->instance() && iface1 == relSides[0]->instance() )
 {
 if( order_switched ) *order_switched = true;
 return true;
 }
 else
 return false;
}
 
bool AssocPair::equivalent( iRel_IfaceType type0, iRel_IfaceType type1, bool* order_switched )
{
 if( type0 == relSides[0]->type() && type1 == relSides[1]->type() )
 {
 if( order_switched ) *order_switched = false;
 return true;
 }
 else if( type0 == relSides[1]->type() && type1 == relSides[0]->type() )
 {
 if( order_switched ) *order_switched = true;
 return true;
 }
 else
 return false;
}
 
bool AssocPair::contains( iBase_Instance iface )
{
 return ( iface == relSides[0]->instance() || iface == relSides[1]->instance() );
}
 
int AssocPair::populate_recursive( int iface_no, iBase_EntitySetHandle set, iBase_EntityHandle related_ent )
{
 iBase_EntityHandle* entities = NULL;
 int entities_alloc = 0, entities_size;
 
 CHK_ERRORR( relSides[iface_no]->get_entities( -1, set, &entities, &entities_alloc, &entities_size ) );
 
 for( int i = 0; i < entities_size; i++ )
 CHK_ERRORR( relSides[iface_no]->set_relation_side( entities + i, 1, &related_ent ) );
 
 free( entities );
 RETURNR( iBase_SUCCESS );
}
 
int AssocPair::populate_recursive( int iface_no, iBase_EntitySetHandle set, iBase_EntitySetHandle related_set )
{
 iBase_EntityHandle* entities = NULL;
 int entities_alloc, entities_size;
 
 CHK_ERRORR( relSides[iface_no]->get_entities( -1, set, &entities, &entities_alloc, &entities_size ) );
 
 for( int i = 0; i < entities_size; i++ )
 CHK_ERRORR( relSides[iface_no]->set_relation_side( entities + i, 1, &related_set ) );
 
 free( entities );
 RETURNR( iBase_SUCCESS );
}
 
int AssocPair::unpopulate_recursive( int iface_no, iBase_EntitySetHandle set )
{
 iBase_EntityHandle* entities = NULL;
 int entities_alloc = 0, entities_size;
 
 CHK_ERRORR( relSides[iface_no]->get_entities( -1, set, &entities, &entities_alloc, &entities_size ) );CHK_ERRORR( relSides[iface_no]->rmv_relation_side( entities, entities_size ) );
 
 free( entities );
 RETURNR( iBase_SUCCESS );
}