MOAB: Mesh Oriented datABase  (version 5.3.1)
iRel_Lasso.cpp
Go to the documentation of this file.
00001 /**
00002  * Copyright 2006 Sandia Corporation.  Under the terms of Contract
00003  * DE-AC04-94AL85000 with Sandia Coroporation, the U.S. Government
00004  * retains certain rights in this software.
00005  *
00006  * This library is free software; you can redistribute it and/or
00007  * modify it under the terms of the GNU Lesser General Public
00008  * License as published by the Free Software Foundation; either
00009  * version 2.1 of the License, or (at your option) any later version.
00010  *
00011  */
00012 #include "iRel_Lasso.hpp"
00013 
00014 #include "Lasso.hpp"
00015 #include "AssocPair.hpp"
00016 #include "ArrayManager.hpp"
00017 
00018 #include <algorithm>
00019 #include <cmath>
00020 #include <cstdio>
00021 #include <iostream>
00022 #include <map>
00023 #include <vector>
00024 
00025 const bool debug = false;
00026 
00027 void iRel_getErrorType( iRel_Instance instance, int* error_type )
00028 {
00029     if( instance == NULL )
00030         *error_type = iBase_FAILURE;
00031     else
00032         *error_type = LASSOI->lastErrorType;
00033 }
00034 
00035 void iRel_getDescription( iRel_Instance instance, char* descr, int descr_len )
00036 {
00037     if( instance == NULL ) { strcpy( descr, "iRel_getDescription: Invalid instance" ); }
00038     else
00039     {
00040         unsigned int len = std::min( strlen( LASSOI->lastErrorDescription ), static_cast< size_t >( descr_len ) );
00041         strncpy( descr, LASSOI->lastErrorDescription, len );
00042         descr[len] = '\0';
00043     }
00044 }
00045 
00046 void iRel_create( /* in */ const char* /* options */, iRel_Instance* instance, int* err, const int options_len )
00047 {
00048     if( 0 != options_len )
00049     {
00050         *instance = NULL;
00051         *err      = iBase_NOT_SUPPORTED;
00052     }
00053 
00054     *instance = new Lasso();
00055     *err      = iBase_SUCCESS;
00056 }
00057 
00058 void iRel_destroy( iRel_Instance instance, int* err )
00059 {
00060     delete LASSOI;
00061     *err = iBase_SUCCESS;
00062 }
00063 
00064 void iRel_createPair( iRel_Instance instance, iBase_Instance iface1, const int ent_or_set1, const int iface_type1,
00065                       const int irel_status1, iBase_Instance iface2, const int ent_or_set2, const int iface_type2,
00066                       const int irel_status2, iRel_PairHandle* pair, int* err )
00067 {
00068     AssocPair* assoc_pair = new AssocPair(
00069         instance, iface1, static_cast< iRel_RelationType >( ent_or_set1 ), static_cast< iRel_IfaceType >( iface_type1 ),
00070         static_cast< iRel_RelationStatus >( irel_status1 ), iface2, static_cast< iRel_RelationType >( ent_or_set2 ),
00071         static_cast< iRel_IfaceType >( iface_type2 ), static_cast< iRel_RelationStatus >( irel_status2 ) );
00072     LASSOI->insert_pair( assoc_pair );
00073 
00074     *pair = reinterpret_cast< iRel_PairHandle >( assoc_pair );
00075     RETURN( iBase_SUCCESS );
00076 }
00077 
00078 void iRel_getPairInfo( iRel_Instance instance, iRel_PairHandle pair, iBase_Instance* iface1, int* ent_or_set1,
00079                        int* iface_type1, int* irel_status1, iBase_Instance* iface2, int* ent_or_set2, int* iface_type2,
00080                        int* irel_status2, int* err )
00081 {
00082     CHK_PAIR();
00083 
00084     *iface1       = ASSOCPAIRI->iface_instance( 0 );
00085     *ent_or_set1  = ASSOCPAIRI->relation_type( 0 );
00086     *iface_type1  = ASSOCPAIRI->iface_type( 0 );
00087     *irel_status1 = ASSOCPAIRI->relation_status( 0 );
00088     *iface2       = ASSOCPAIRI->iface_instance( 1 );
00089     *iface_type2  = ASSOCPAIRI->iface_type( 1 );
00090     *ent_or_set2  = ASSOCPAIRI->relation_type( 1 );
00091     *irel_status2 = ASSOCPAIRI->relation_status( 1 );
00092 
00093     RETURN( iBase_SUCCESS );
00094 }
00095 
00096 void iRel_changePairType( iRel_Instance instance, iRel_PairHandle pair, int ent_or_set1, int ent_or_set2, int* err )
00097 {
00098     CHK_PAIR();
00099 
00100     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 ) ) );
00101 }
00102 
00103 void iRel_changePairStatus( iRel_Instance instance, iRel_PairHandle pair, int irel_status1, int irel_status2, int* err )
00104 {
00105     CHK_PAIR();
00106 
00107     CHK_ERROR( ASSOCPAIRI->change_status( 0, static_cast< iRel_RelationStatus >( irel_status1 ) ) );CHK_ERROR( ASSOCPAIRI->change_status( 1, static_cast< iRel_RelationStatus >( irel_status2 ) ) );
00108 }
00109 
00110 void iRel_destroyPair( iRel_Instance instance, iRel_PairHandle pair, int* err )
00111 {
00112     CHK_PAIR();
00113 
00114     CHK_ERROR( LASSOI->erase_pair( ASSOCPAIRI ) );
00115 }
00116 
00117 void iRel_findPairs( iRel_Instance instance, iBase_Instance iface, iRel_PairHandle** pairs, int* pairs_allocated,
00118                      int* pairs_size, int* err )
00119 {
00120     std::vector< AssocPair* > tmp_pairs;
00121     LASSOI->find_pairs( iface, tmp_pairs );
00122 
00123     ALLOC_CHECK_ARRAY_NOFAIL( pairs, tmp_pairs.size() );
00124     for( size_t i = 0; i < tmp_pairs.size(); ++i )
00125     {
00126         ( *pairs )[i] = reinterpret_cast< iRel_PairHandle >( tmp_pairs[i] );
00127     }
00128 
00129     RETURN( iBase_SUCCESS );
00130 }
00131 
00132 void iRel_setEntEntRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle ent1,
00133                              iBase_EntityHandle ent2, int* err )
00134 {
00135     CHK_PAIR();CHK_ERROR( ASSOCPAIRI->set_relation( ent1, ent2 ) );
00136 }
00137 
00138 void iRel_setEntSetRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle ent1,
00139                              iBase_EntitySetHandle set2, int* err )
00140 {
00141     CHK_PAIR();CHK_ERROR( ASSOCPAIRI->set_relation( ent1, set2 ) );
00142 }
00143 
00144 void iRel_setSetEntRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle set1,
00145                              iBase_EntityHandle ent2, int* err )
00146 {
00147     CHK_PAIR();CHK_ERROR( ASSOCPAIRI->set_relation( set1, ent2 ) );
00148 }
00149 
00150 void iRel_setSetSetRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle set1,
00151                              iBase_EntitySetHandle set2, int* err )
00152 {
00153     CHK_PAIR();CHK_ERROR( ASSOCPAIRI->set_relation( set1, set2 ) );
00154 }
00155 
00156 void iRel_setEntArrEntArrRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle* ent_array_1,
00157                                    int num_entities1, iBase_EntityHandle* ent_array_2, int num_entities2, int* err )
00158 {
00159     CHK_PAIR();
00160 
00161     if( num_entities1 != num_entities2 )
00162         ERROR( iBase_INVALID_ENTITY_COUNT, "setEntArrEntArrRelation doesn't support "
00163                                            "different #'s of entities." );
00164 
00165     int result = iBase_SUCCESS;
00166     char descr[200];
00167     for( int i = 0; i < num_entities1; i++ )
00168     {
00169         int tmp_result = ASSOCPAIRI->set_relation( ent_array_1[i], ent_array_2[i] );
00170         if( result == iBase_SUCCESS && tmp_result != iBase_SUCCESS )
00171         {
00172             result = tmp_result;
00173             iRel_getDescription( instance, descr, sizeof( descr ) );
00174         }
00175     }
00176 
00177     if( result != iBase_SUCCESS ) ERROR( result, descr );
00178     RETURN( iBase_SUCCESS );
00179 }
00180 
00181 void iRel_setEntArrSetArrRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle* ent_array_1,
00182                                    int num_entities1, iBase_EntitySetHandle* set_array_2, int num_sets2, int* err )
00183 {
00184     CHK_PAIR();
00185 
00186     if( num_entities1 != num_sets2 )
00187         ERROR( iBase_INVALID_ENTITY_COUNT, "setEntArrSetArrRelation doesn't support "
00188                                            "different #'s of entities." );
00189 
00190     int result = iBase_SUCCESS;
00191     char descr[200];
00192     for( int i = 0; i < num_entities1; i++ )
00193     {
00194         int tmp_result = ASSOCPAIRI->set_relation( ent_array_1[i], set_array_2[i] );
00195         if( result == iBase_SUCCESS && tmp_result != iBase_SUCCESS )
00196         {
00197             result = tmp_result;
00198             iRel_getDescription( instance, descr, sizeof( descr ) );
00199         }
00200     }
00201 
00202     if( result != iBase_SUCCESS ) ERROR( result, descr );
00203     RETURN( iBase_SUCCESS );
00204 }
00205 
00206 void iRel_setSetArrEntArrRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle* set_array_1,
00207                                    int num_sets1, iBase_EntityHandle* ent_array_2, int num_entities2, int* err )
00208 {
00209     CHK_PAIR();
00210 
00211     if( num_sets1 != num_entities2 )
00212         ERROR( iBase_INVALID_ENTITY_COUNT, "setSetArrEntArrRelation doesn't support "
00213                                            "different #'s of entities." );
00214 
00215     int result = iBase_SUCCESS;
00216     char descr[200];
00217     for( int i = 0; i < num_sets1; i++ )
00218     {
00219         int tmp_result = ASSOCPAIRI->set_relation( set_array_1[i], ent_array_2[i] );
00220         if( result == iBase_SUCCESS && tmp_result != iBase_SUCCESS )
00221         {
00222             result = tmp_result;
00223             iRel_getDescription( instance, descr, sizeof( descr ) );
00224         }
00225     }
00226 
00227     if( result != iBase_SUCCESS ) ERROR( result, descr );
00228     RETURN( iBase_SUCCESS );
00229 }
00230 
00231 void iRel_setSetArrSetArrRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle* set_array_1,
00232                                    int num_sets1, iBase_EntitySetHandle* set_array_2, int num_sets2, int* err )
00233 {
00234     CHK_PAIR();
00235 
00236     if( num_sets1 != num_sets2 )
00237         ERROR( iBase_INVALID_ENTITY_COUNT, "setSetArrSetArrRelation doesn't support "
00238                                            "different #'s of entities." );
00239 
00240     int result = iBase_SUCCESS;
00241     char descr[200];
00242     for( int i = 0; i < num_sets1; i++ )
00243     {
00244         int tmp_result = ASSOCPAIRI->set_relation( set_array_1[i], set_array_2[i] );
00245         if( result == iBase_SUCCESS && tmp_result != iBase_SUCCESS )
00246         {
00247             result = tmp_result;
00248             iRel_getDescription( instance, descr, sizeof( descr ) );
00249         }
00250     }
00251 
00252     if( result != iBase_SUCCESS ) ERROR( result, descr );
00253     RETURN( iBase_SUCCESS );
00254 }
00255 
00256 void iRel_getEntEntRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle ent1, int switch_order,
00257                              iBase_EntityHandle* ent2, int* err )
00258 {
00259     CHK_PAIR();
00260 
00261     int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, &ent1, 1, ent2 ) );
00262 }
00263 
00264 void iRel_getEntSetRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle ent1, int switch_order,
00265                              iBase_EntitySetHandle* set2, int* err )
00266 {
00267     CHK_PAIR();
00268 
00269     int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, &ent1, 1, set2 ) );
00270 }
00271 
00272 void iRel_getSetEntRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle set1, int switch_order,
00273                              iBase_EntityHandle* ent2, int* err )
00274 {
00275     CHK_PAIR();
00276 
00277     int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, &set1, 1, ent2 ) );
00278 }
00279 
00280 void iRel_getSetSetRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle set1, int switch_order,
00281                              iBase_EntitySetHandle* set2, int* err )
00282 {
00283     CHK_PAIR();
00284 
00285     int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, &set1, 1, set2 ) );
00286 }
00287 
00288 void iRel_getEntSetIterRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle ent1,
00289                                  int switch_order, iBase_EntityIterator* entset2, int* err )
00290 {
00291     CHK_PAIR();
00292 
00293     int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, &ent1, 1, entset2 ) );
00294 }
00295 
00296 void iRel_getEntArrEntArrRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle* ent_array_1,
00297                                    int ent_array_1_size, int switch_order, iBase_EntityHandle** ent_array_2,
00298                                    int* ent_array_2_allocated, int* ent_array_2_size, int* err )
00299 {
00300     CHK_PAIR();
00301 
00302     int iface_no = ( switch_order ? 1 : 0 );
00303     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 ) );
00304 
00305     KEEP_ARRAY( ent_array_2 );
00306     RETURN( iBase_SUCCESS );
00307 }
00308 
00309 void iRel_getEntArrSetArrRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle* ent_array_1,
00310                                    int ent_array_1_size, int switch_order, iBase_EntitySetHandle** set_array_2,
00311                                    int* set_array_2_allocated, int* set_array_2_size, int* err )
00312 {
00313     CHK_PAIR();
00314 
00315     int iface_no = ( switch_order ? 1 : 0 );
00316     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 ) );
00317 
00318     KEEP_ARRAY( set_array_2 );
00319     RETURN( iBase_SUCCESS );
00320 }
00321 
00322 void iRel_getSetArrEntArrRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle* set_array_1,
00323                                    int set_array_1_size, int switch_order, iBase_EntityHandle** ent_array_2,
00324                                    int* ent_array_2_allocated, int* ent_array_2_size, int* err )
00325 {
00326     CHK_PAIR();
00327 
00328     int iface_no = ( switch_order ? 1 : 0 );
00329     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 ) );
00330 
00331     KEEP_ARRAY( ent_array_2 );
00332     RETURN( iBase_SUCCESS );
00333 }
00334 
00335 void iRel_getSetArrSetArrRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle* set_array_1,
00336                                    int set_array_1_size, int switch_order, iBase_EntitySetHandle** set_array_2,
00337                                    int* set_array_2_allocated, int* set_array_2_size, int* err )
00338 {
00339     CHK_PAIR();
00340 
00341     int iface_no = ( switch_order ? 1 : 0 );
00342     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 ) );
00343 
00344     KEEP_ARRAY( set_array_2 );
00345     RETURN( iBase_SUCCESS );
00346 }
00347 
00348 void iRel_getEntArrSetIterArrRelation( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle* ent_array_1,
00349                                        int ent_array_1_size, int switch_order, iBase_EntityIterator** entiter,
00350                                        int* entiter_allocated, int* entiter_size, int* err )
00351 {
00352     CHK_PAIR();
00353 
00354     int iface_no = ( switch_order ? 1 : 0 );
00355     ;
00356     ALLOC_CHECK_ARRAY( entiter, ent_array_1_size );CHK_ERROR( ASSOCPAIRI->get_relation( iface_no, ent_array_1, ent_array_1_size, *entiter ) );
00357 
00358     KEEP_ARRAY( entiter );
00359     RETURN( iBase_SUCCESS );
00360 }
00361 
00362 void iRel_rmvEntRelation( iRel_Instance instance,
00363                           /*in*/ iRel_PairHandle pair,
00364                           /*in*/ iBase_EntityHandle ent,
00365                           /*in*/ int switch_order,
00366                           /*out*/ int* err )
00367 {
00368     CHK_PAIR();
00369 
00370     int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->rmv_relation( iface_no, &ent, 1 ) );
00371 }
00372 
00373 void iRel_rmvSetRelation( iRel_Instance instance,
00374                           /*in*/ iRel_PairHandle pair,
00375                           /*in*/ iBase_EntitySetHandle entset,
00376                           /*in*/ int switch_order,
00377                           /*out*/ int* err )
00378 {
00379     CHK_PAIR();
00380 
00381     int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->rmv_relation( iface_no, &entset, 1 ) );
00382 }
00383 
00384 void iRel_rmvEntArrRelation( iRel_Instance instance,
00385                              /*in*/ iRel_PairHandle pair,
00386                              /*in*/ iBase_EntityHandle* ent_array,
00387                              /*in*/ int num_ent,
00388                              /*in*/ int switch_order,
00389                              /*out*/ int* err )
00390 {
00391     CHK_PAIR();
00392 
00393     int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->rmv_relation( iface_no, ent_array, num_ent ) );
00394 }
00395 
00396 void iRel_rmvSetArrRelation( iRel_Instance instance,
00397                              /*in*/ iRel_PairHandle pair,
00398                              /*in*/ iBase_EntitySetHandle* entset_array,
00399                              /*in*/ int num_ent,
00400                              /*in*/ int switch_order,
00401                              /*out*/ int* err )
00402 {
00403     CHK_PAIR();
00404 
00405     int iface_no = ( switch_order ? 1 : 0 );CHK_ERROR( ASSOCPAIRI->rmv_relation( iface_no, entset_array, num_ent ) );
00406 }
00407 
00408 static int get_gids_and_dims( iRel_PairHandle pair, int iface_no, iBase_EntityHandle* ents, int ents_size,
00409                               int ent_or_set, std::vector< int >& ents_gids, std::vector< int >& ents_dims )
00410 {
00411     int result;
00412     iBase_EntitySetHandle* sets = reinterpret_cast< iBase_EntitySetHandle* >( ents );
00413 
00414     ents_gids.resize( ents_size );
00415     if( ent_or_set == iRel_ENTITY )
00416         result = ASSOCPAIRI->get_gids( iface_no, ents, ents_size, &ents_gids[0] );
00417     else
00418         result = ASSOCPAIRI->get_gids( iface_no, sets, ents_size, &ents_gids[0] );
00419 
00420     if( iBase_SUCCESS != result && iBase_TAG_NOT_FOUND != result ) return result;
00421 
00422     ents_dims.resize( ents_size, -1 );
00423     if( ent_or_set == iRel_ENTITY )
00424     {
00425         int* ents_dims_ptr  = &ents_dims[0];
00426         int ents_dims_alloc = ents_dims.size(), ents_dims_size;
00427         result =
00428             ASSOCPAIRI->get_ents_dims( iface_no, ents, ents_size, &ents_dims_ptr, &ents_dims_alloc, &ents_dims_size );
00429     }
00430     else
00431     {
00432         result = ASSOCPAIRI->get_dims( iface_no, sets, ents_size, &ents_dims[0] );
00433     }
00434 
00435     if( iBase_SUCCESS != result && iBase_TAG_NOT_FOUND != result ) return result;
00436 
00437     return iBase_SUCCESS;
00438 }
00439 
00440 static void iRel_inferArrArrRelations( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle* ents1,
00441                                        const int ents1_size, int ent_or_set1, iBase_EntityHandle* ents2,
00442                                        const int ents2_size, int ent_or_set2, int* err )
00443 {
00444     int result;
00445 
00446     std::vector< int > ents_gids, ents_dims;
00447     std::map< const int, iBase_EntityHandle > ents_gid_map[4];
00448 
00449     get_gids_and_dims( pair, 0, ents1, ents1_size, ent_or_set1, ents_gids, ents_dims );
00450     for( int i = 0; i < ents1_size; i++ )
00451     {
00452         int dim = ents_dims[i];
00453         if( 0 <= dim && 3 >= dim ) ents_gid_map[dim][ents_gids[i]] = ents1[i];
00454     }
00455 
00456     get_gids_and_dims( pair, 1, ents2, ents2_size, ent_or_set2, ents_gids, ents_dims );
00457     for( int i = 0; i < ents2_size; i++ )
00458     {
00459         int dim = ents_dims[i];
00460 
00461         // only check entities for which the dimension entry is in a reasonable
00462         // range
00463         if( 0 > dim || 3 < dim ) continue;
00464 
00465         // there's a match if there's an entity with that dimension with matching id
00466         std::map< const int, iBase_EntityHandle >::iterator iter = ents_gid_map[dim].find( ents_gids[i] );
00467 
00468         // if it matches, set the relation tags for those entities
00469         if( iter != ents_gid_map[dim].end() )
00470         {
00471             if( ent_or_set1 == iRel_ENTITY && ent_or_set2 == iRel_ENTITY )
00472             {
00473                 result = ASSOCPAIRI->set_relation( ( *iter ).second, ents2[i] );
00474             }
00475             else if( ent_or_set1 != iRel_ENTITY && ent_or_set2 == iRel_ENTITY )
00476             {
00477                 result = ASSOCPAIRI->set_relation( ( iBase_EntitySetHandle )( *iter ).second, ents2[i] );
00478             }
00479             else if( ent_or_set1 == iRel_ENTITY && ent_or_set2 != iRel_ENTITY )
00480             {
00481                 result = ASSOCPAIRI->set_relation( ( *iter ).second, (iBase_EntitySetHandle)ents2[i] );
00482             }
00483             else
00484             {  // ent_or_set1 != iRel_ENTITY && ent_or_set2 != iRel_ENTITY
00485                 result = ASSOCPAIRI->set_relation( ( iBase_EntitySetHandle )( *iter ).second,
00486                                                    (iBase_EntitySetHandle)ents2[i] );
00487             }
00488 
00489             CHK_ERROR( result );
00490         }
00491     }
00492 
00493     RETURN( iBase_SUCCESS );
00494 }
00495 
00496 void iRel_inferEntArrEntArrRelations( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle* ents1,
00497                                       const int ents1_size, iBase_EntityHandle* ents2, const int ents2_size, int* err )
00498 {
00499     iRel_inferArrArrRelations( instance, pair, ents1, ents1_size, 0, ents2, ents2_size, 0, err );
00500 }
00501 
00502 void iRel_inferEntArrSetArrRelations( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle* ents1,
00503                                       const int ents1_size, iBase_EntitySetHandle* ents2, const int ents2_size,
00504                                       int* err )
00505 {
00506     iRel_inferArrArrRelations( instance, pair, ents1, ents1_size, 0, (iBase_EntityHandle*)ents2, ents2_size, 1, err );
00507 }
00508 
00509 void iRel_inferSetArrEntArrRelations( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle* ents1,
00510                                       const int ents1_size, iBase_EntityHandle* ents2, const int ents2_size, int* err )
00511 {
00512     iRel_inferArrArrRelations( instance, pair, (iBase_EntityHandle*)ents1, ents1_size, 1, ents2, ents2_size, 0, err );
00513 }
00514 
00515 void iRel_inferSetArrSetArrRelations( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle* ents1,
00516                                       const int ents1_size, int /*is_set1*/, iBase_EntitySetHandle* ents2,
00517                                       const int ents2_size, int /*is_set2*/, int* err )
00518 
00519 {
00520     iRel_inferArrArrRelations( instance, pair, (iBase_EntityHandle*)ents1, ents1_size, 1, (iBase_EntityHandle*)ents2,
00521                                ents2_size, 1, err );
00522 }
00523 
00524 void iRel_inferAllRelations( iRel_Instance instance, iRel_PairHandle pair, int* err )
00525 {
00526     CHK_PAIR();
00527 
00528     // get all entities in those interfaces
00529     int result;
00530 
00531     iBase_EntityHandle* ents1 = NULL;
00532     int ents1_alloc           = 0, ents1_size;
00533     if( ASSOCPAIRI->relation_type( 0 ) != iRel_ENTITY )
00534         result = ASSOCPAIRI->get_all_sets( 0, (iBase_EntitySetHandle**)&ents1, &ents1_alloc, &ents1_size );
00535     else
00536         result = ASSOCPAIRI->get_all_entities( 0, -1, &ents1, &ents1_alloc, &ents1_size );CHK_ERROR( result );
00537 
00538     iBase_EntityHandle* ents2 = NULL;
00539     int ents2_alloc           = 0, ents2_size;
00540     if( ASSOCPAIRI->relation_type( 1 ) != iRel_ENTITY )
00541         result = ASSOCPAIRI->get_all_sets( 1, (iBase_EntitySetHandle**)&ents2, &ents2_alloc, &ents2_size );
00542     else
00543         result = ASSOCPAIRI->get_all_entities( 1, -1, &ents2, &ents2_alloc, &ents2_size );CHK_ERROR( result );
00544 
00545     iRel_inferArrArrRelations( instance, pair, ents1, ents1_size, ASSOCPAIRI->relation_type( 0 ), ents2, ents2_size,
00546                                ASSOCPAIRI->relation_type( 1 ), &result );
00547 
00548     free( ents1 );
00549     free( ents2 );CHK_ERROR( result );
00550 }
00551 
00552 void iRel_inferAllRelationsAndType( iRel_Instance instance, iRel_PairHandle* /*pair*/, int* err )
00553 {
00554     ERROR( iBase_NOT_SUPPORTED, "Not currently supported." );
00555 }
00556 
00557 void iRel_inferEntRelations( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle entity, int iface_no,
00558                              int* err )
00559 {
00560     iRel_inferEntArrRelations( instance, pair, &entity, 1, iface_no, err );
00561 }
00562 
00563 void iRel_inferSetRelations( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle entity, int iface_no,
00564                              int* err )
00565 {
00566     iRel_inferSetArrRelations( instance, pair, &entity, 1, iface_no, err );
00567 }
00568 
00569 static void iRel_inferArrRelations( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle* entities,
00570                                     int entities_size, bool is_set, int iface_no, int* err )
00571 {
00572     CHK_PAIR();
00573 
00574     if( 0 > iface_no || 1 < iface_no ) { ERROR( iBase_INVALID_ARGUMENT, "Interface number must be 0 or 1" ); }
00575     else if( ( is_set && ASSOCPAIRI->relation_type( iface_no ) == iRel_ENTITY ) ||
00576              ( !is_set && ASSOCPAIRI->relation_type( iface_no ) != iRel_ENTITY ) )
00577     {
00578         ERROR( iBase_INVALID_ARGUMENT, "is_set must match entOrSet in call to "
00579                                        "inferArrRelations" );
00580     }
00581 
00582     // get all entities in iface2
00583     int result;
00584     iBase_EntityHandle* ents1 = entities;
00585     int ents1_size            = entities_size;
00586     iBase_EntityHandle* ents2 = NULL;
00587     int ents2_alloc           = 0, ents2_size;
00588     if( ASSOCPAIRI->relation_type( 1 - iface_no ) != iRel_ENTITY )
00589         result = ASSOCPAIRI->get_all_sets( !iface_no, (iBase_EntitySetHandle**)&ents2, &ents2_alloc, &ents2_size );
00590     else
00591         result = ASSOCPAIRI->get_all_entities( !iface_no, -1, &ents2, &ents2_alloc, &ents2_size );CHK_ERROR( result );
00592 
00593     // switch so that entity lists always go into inferArrArrRelations in
00594     // forward order wrt pair
00595     if( 1 == iface_no )
00596     {
00597         std::swap( ents1, ents2 );
00598         std::swap( ents1_size, ents2_size );
00599     }
00600 
00601     iRel_inferArrArrRelations( instance, pair, ents1, ents1_size, ASSOCPAIRI->relation_type( 0 ), ents2, ents2_size,
00602                                ASSOCPAIRI->relation_type( 1 ), &result );
00603 
00604     free( 1 == iface_no ? ents1 : ents2 );
00605 
00606     CHK_ERROR( result );
00607 }
00608 
00609 void iRel_inferEntArrRelations( iRel_Instance instance, iRel_PairHandle pair, iBase_EntityHandle* entities,
00610                                 int entities_size, int iface_no, int* err )
00611 {
00612     iRel_inferArrRelations( instance, pair, entities, entities_size, false, iface_no, err );
00613 }
00614 
00615 void iRel_inferSetArrRelations( iRel_Instance instance, iRel_PairHandle pair, iBase_EntitySetHandle* entities,
00616                                 int entities_size, int iface_no, int* err )
00617 {
00618     iRel_inferArrRelations( instance, pair, (iBase_EntityHandle*)entities, entities_size, true, iface_no, err );
00619 }
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines