Branch data Line data Source code
1 : :
2 : : #ifndef IBSH
3 : : #define IBSH(h) reinterpret_cast<iBase_EntitySetHandle>(h)
4 : : #endif
5 : :
6 : : #ifndef IBSHR
7 : : #define IBSHR(h) reinterpret_cast<iBase_EntitySetHandle&>(h)
8 : : #endif
9 : :
10 : : #ifndef IBEH
11 : : #define IBEH(h) reinterpret_cast<iBase_EntityHandle>(h)
12 : : #endif
13 : :
14 : : #ifndef IBEHR
15 : : #define IBEHR(h) reinterpret_cast<iBase_EntityHandle&>(h)
16 : : #endif
17 : :
18 : : #define PFX__(A,B) A ## B
19 : : #define PFX_(A,B) PFX__(A,B)
20 : : #define PFX(B) PFX_( ITAPS_PREFIX, B )
21 : :
22 : 65 : class PFX(Base) {
23 : : protected:
24 : : PFX(_Instance) mInstance;
25 : :
26 : : public:
27 : : typedef iBase_EntitySetHandle EntitySetHandle;
28 : : typedef iBase_EntityHandle EntityHandle;
29 : : typedef iBase_TagHandle TagHandle;
30 : : typedef iBase_ErrorType Error;
31 : : typedef iBase_EntityType EntityType;
32 : : typedef iBase_StorageOrder StorageOrder;
33 : : typedef iBase_TagValueType TagValueType;
34 : :
35 : : inline PFX(_Instance) instance();
36 : :
37 : : inline Error getErrorType() const;
38 : :
39 : : inline std::string getDescription() const;
40 : :
41 : : inline EntitySetHandle getRootSet() const;
42 : :
43 : : inline Error createEntSet( bool is_list, EntitySetHandle& handle_out );
44 : : inline Error destroyEntSet( EntitySetHandle handle );
45 : : inline Error isList( EntitySetHandle handle, bool& is_list ) const;
46 : :
47 : : inline Error getNumEntSets( EntitySetHandle set, int num_hops, int& num_sets_out ) const;
48 : : inline Error getEntSets( EntitySetHandle set, int num_hops,
49 : : std::vector<EntitySetHandle>& contained_sets_out ) const;
50 : :
51 : : inline Error addEntToSet( EntityHandle entity, EntitySetHandle set );
52 : : inline Error rmvEntFromSet( EntityHandle entity, EntitySetHandle set );
53 : :
54 : : inline Error addEntArrToSet( const EntityHandle* entity_handles,
55 : : int entity_handles_size,
56 : : EntitySetHandle entity_set );
57 : : inline Error rmvEntArrFromSet( const EntityHandle* entity_handles,
58 : : int entity_handles_size,
59 : : EntitySetHandle entity_set );
60 : :
61 : : inline Error addEntSet( EntitySetHandle to_add, EntitySetHandle add_to );
62 : : inline Error rmvEntSet( EntitySetHandle to_rmv, EntitySetHandle rmv_from );
63 : :
64 : : inline Error isEntContained( EntitySetHandle set, EntityHandle ent, bool& contained_out ) const;
65 : : inline Error isEntArrContained( EntitySetHandle containing_set,
66 : : const EntityHandle* entity_handles,
67 : : int num_entity_handles,
68 : : bool* is_contained_out ) const;
69 : : inline Error isEntSetContained( EntitySetHandle containing_set,
70 : : EntitySetHandle contained_set,
71 : : bool& contained_out ) const;
72 : :
73 : : inline Error addPrntChld( EntitySetHandle parent, EntitySetHandle child );
74 : : inline Error rmvPrntChld( EntitySetHandle parent, EntitySetHandle child );
75 : : inline Error isChildOf( EntitySetHandle parent, EntitySetHandle child, bool& is_child_out ) const;
76 : : inline Error getNumChld( EntitySetHandle parent, int num_hops, int& num_child_out ) const;
77 : : inline Error getNumPrnt( EntitySetHandle child, int num_hops, int& num_parent_out ) const;
78 : : inline Error getChldn( EntitySetHandle parent, int num_hops,
79 : : std::vector<EntitySetHandle>& children_out ) const;
80 : : inline Error getPrnts( EntitySetHandle child, int num_hops,
81 : : std::vector<EntitySetHandle>& parents_out ) const;
82 : :
83 : : inline Error subtract( EntitySetHandle set1, EntitySetHandle set2,
84 : : EntitySetHandle& result_set_out );
85 : : inline Error intersect( EntitySetHandle set1, EntitySetHandle set2,
86 : : EntitySetHandle& result_set_out );
87 : : inline Error unite( EntitySetHandle set1, EntitySetHandle set2,
88 : : EntitySetHandle& result_set_out );
89 : :
90 : : inline Error createTag( const char* tag_name,
91 : : int tag_num_type_values,
92 : : TagValueType tag_type,
93 : : TagHandle& tag_handle_out );
94 : :
95 : : inline Error destroyTag( TagHandle tag_handle, bool forced );
96 : : inline Error getTagName( TagHandle tag_handle, std::string& name_out ) const;
97 : : inline Error getTagSizeValues( TagHandle tag_handle, int& size_out ) const;
98 : : inline Error getTagSizeBytes( TagHandle tag_handle, int& size_out ) const;
99 : : inline Error getTagHandle( const char* name, TagHandle& handle_out ) const;
100 : : inline Error getTagType( TagHandle tag_handle, TagValueType& type_out ) const;
101 : :
102 : : inline Error setEntSetData( EntitySetHandle set_handle,
103 : : TagHandle tag_handle,
104 : : const void* tag_value );
105 : : inline Error setEntSetIntData( EntitySetHandle set_handle,
106 : : TagHandle tag_handle,
107 : : int value );
108 : : inline Error setEntSetDblData( EntitySetHandle set_handle,
109 : : TagHandle tag_handle,
110 : : double value );
111 : : inline Error setEntSetEHData( EntitySetHandle set_handle,
112 : : TagHandle tag_handle,
113 : : EntityHandle value );
114 : : inline Error setEntSetESHData( EntitySetHandle set_handle,
115 : : TagHandle tag_handle,
116 : : EntitySetHandle value );
117 : :
118 : : inline Error getEntSetData( EntitySetHandle set_handle,
119 : : TagHandle tag_handle,
120 : : void* tag_value_out ) const;
121 : : inline Error getEntSetIntData( EntitySetHandle set_handle,
122 : : TagHandle tag_handle,
123 : : int& value_out ) const;
124 : : inline Error getEntSetDblData( EntitySetHandle set_handle,
125 : : TagHandle tag_handle,
126 : : double& value_out ) const;
127 : : inline Error getEntSetEHData( EntitySetHandle set_handle,
128 : : TagHandle tag_handle,
129 : : EntityHandle& value_out ) const;
130 : : inline Error getEntSetESHData( EntitySetHandle set_handle,
131 : : TagHandle tag_handle,
132 : : EntitySetHandle& value_out ) const;
133 : :
134 : : inline Error getAllEntSetTags( EntitySetHandle set,
135 : : std::vector<TagHandle>& tags_out ) const;
136 : : inline Error getAllTags( EntityHandle entity,
137 : : std::vector<TagHandle>& tags_out ) const;
138 : :
139 : : inline Error rmvEntSetTag( EntitySetHandle set, TagHandle tag );
140 : : inline Error rmvTag( EntityHandle entity, TagHandle tag );
141 : : inline Error rmvArrTag( const EntityHandle* handles, int size, TagHandle tag );
142 : :
143 : : inline Error getArrData( const EntityHandle* entity_handles,
144 : : int entity_handles_size,
145 : : TagHandle tag_handle,
146 : : void* tag_values_out ) const;
147 : : inline Error getIntArrData( const EntityHandle* entity_handles,
148 : : int entity_handles_size,
149 : : TagHandle tag_handle,
150 : : int* tag_values_out ) const;
151 : : inline Error getDblArrData( const EntityHandle* entity_handles,
152 : : int entity_handles_size,
153 : : TagHandle tag_handle,
154 : : double* tag_values_out ) const;
155 : : inline Error getEHArrData( const EntityHandle* entity_handles,
156 : : int entity_handles_size,
157 : : TagHandle tag_handle,
158 : : EntityHandle* tag_values_out ) const;
159 : : inline Error getESHArrData( const EntityHandle* entity_handles,
160 : : int entity_handles_size,
161 : : TagHandle tag_handle,
162 : : EntitySetHandle* tag_values_out ) const;
163 : :
164 : : inline Error setArrData( const EntityHandle* entity_handles,
165 : : int entity_handles_size,
166 : : TagHandle tag_handle,
167 : : const void* tag_values );
168 : : inline Error setIntArrData( const EntityHandle* entity_handles,
169 : : int entity_handles_size,
170 : : TagHandle tag_handle,
171 : : const int* tag_values );
172 : : inline Error setDblArrData( const EntityHandle* entity_handles,
173 : : int entity_handles_size,
174 : : TagHandle tag_handle,
175 : : const double* tag_values );
176 : : inline Error setEHArrData( const EntityHandle* entity_handles,
177 : : int entity_handles_size,
178 : : TagHandle tag_handle,
179 : : const EntityHandle* tag_values );
180 : : inline Error setESHArrData( const EntityHandle* entity_handles,
181 : : int entity_handles_size,
182 : : TagHandle tag_handle,
183 : : const EntitySetHandle* tag_values );
184 : :
185 : :
186 : : inline Error setData( EntityHandle entity_handle,
187 : : TagHandle tag_handle,
188 : : const void* tag_value );
189 : : inline Error setIntData( EntityHandle entity_handle,
190 : : TagHandle tag_handle,
191 : : int value );
192 : : inline Error setDblData( EntityHandle entity_handle,
193 : : TagHandle tag_handle,
194 : : double value );
195 : : inline Error setEHData( EntityHandle entity_handle,
196 : : TagHandle tag_handle,
197 : : EntityHandle value );
198 : : inline Error setESHData( EntityHandle entity_handle,
199 : : TagHandle tag_handle,
200 : : EntitySetHandle value );
201 : :
202 : : inline Error getData( EntityHandle entity_handle,
203 : : TagHandle tag_handle,
204 : : void* tag_value_out ) const;
205 : : inline Error getIntData( EntityHandle entity_handle,
206 : : TagHandle tag_handle,
207 : : int& value_out ) const;
208 : : inline Error getDblData( EntityHandle entity_handle,
209 : : TagHandle tag_handle,
210 : : double& value_out ) const;
211 : : inline Error getEHData( EntityHandle entity_handle,
212 : : TagHandle tag_handle,
213 : : EntityHandle& value_out ) const;
214 : : inline Error getESHData( EntityHandle entity_handle,
215 : : TagHandle tag_handle,
216 : : EntitySetHandle& value_out ) const;
217 : : };
218 : :
219 : :
220 : 173 : inline PFX(_Instance) PFX(Base)::instance()
221 : : {
222 : 173 : return mInstance;
223 : : }
224 : :
225 : : inline PFX(Base)::Error
226 : : PFX(Base)::getErrorType() const
227 : : {
228 : : int err;
229 : : PFX(_getErrorType)( mInstance, &err);
230 : : return (Error)err;
231 : : }
232 : :
233 : : inline std::string
234 : 0 : PFX(Base)::getDescription() const
235 : : {
236 [ # # ]: 0 : std::vector<char> buffer(1024);
237 [ # # ][ # # ]: 0 : PFX(_getDescription)( mInstance, &buffer[0], buffer.size() );
238 [ # # ][ # # ]: 0 : return std::string(&buffer[0]);
239 : : }
240 : :
241 : :
242 : :
243 : :
244 : : inline PFX(Base)::EntitySetHandle
245 : 18 : PFX(Base)::getRootSet() const
246 : : {
247 : : int err;
248 : : EntitySetHandle result;
249 [ + - ]: 18 : PFX(_getRootSet)( mInstance, &result, &err );
250 [ + - ]: 18 : return iBase_SUCCESS == err ? result : 0;
251 : : }
252 : :
253 : :
254 : :
255 : : inline PFX(Base)::Error
256 : 21 : PFX(Base)::createEntSet( bool is_list, EntitySetHandle& handle_out )
257 : : {
258 : : int err;
259 [ + - ]: 21 : PFX(_createEntSet)( mInstance, is_list, &handle_out, &err );
260 : 21 : return (Error)err;
261 : : }
262 : :
263 : : inline PFX(Base)::Error
264 : 7 : PFX(Base)::destroyEntSet( EntitySetHandle handle )
265 : : {
266 : : int err;
267 [ + - ]: 7 : PFX(_destroyEntSet)( mInstance, handle, &err );
268 : 7 : return (Error)err;
269 : : }
270 : :
271 : : inline PFX(Base)::Error
272 : : PFX(Base)::isList( EntitySetHandle handle, bool& is_list ) const
273 : : {
274 : : int err, result;
275 : : PFX(_isList)( mInstance, handle, &result, &err );
276 : : is_list = (result != 0);
277 : : return (Error)err;
278 : : }
279 : :
280 : : inline PFX(Base)::Error
281 : : PFX(Base)::getNumEntSets( EntitySetHandle set, int num_hops, int& num_sets_out ) const
282 : : {
283 : : int err;
284 : : PFX(_getNumEntSets)( mInstance, set, num_hops, &num_sets_out, &err );
285 : : return (Error)err;
286 : : }
287 : :
288 : : inline PFX(Base)::Error
289 : 49 : PFX(Base)::getEntSets( EntitySetHandle set, int num_hops,
290 : : std::vector<EntitySetHandle>& contained_sets_out ) const
291 : : {
292 : : int err, count;
293 [ + - ]: 49 : PFX(_getNumEntSets)( mInstance, set, num_hops, &count, &err );
294 [ - + ]: 49 : if (iBase_SUCCESS != err)
295 : 0 : return (Error)err;
296 [ + - ]: 49 : contained_sets_out.resize(count);
297 : 49 : int alloc = contained_sets_out.size(), size;
298 [ + - ]: 49 : EntitySetHandle* ptr = &contained_sets_out[0];
299 [ + - ]: 49 : PFX(_getEntSets)( mInstance, set, num_hops, &ptr, &alloc, &size, &err );
300 : 49 : return (Error)err;
301 : : }
302 : :
303 : : inline PFX(Base)::Error
304 : 1440 : PFX(Base)::addEntToSet( EntityHandle entity, EntitySetHandle set )
305 : : {
306 : : int err;
307 [ + - ]: 1440 : PFX(_addEntToSet)( mInstance, entity,set, &err );
308 : 1440 : return (Error)err;
309 : : }
310 : :
311 : : inline PFX(Base)::Error
312 : : PFX(Base)::rmvEntFromSet( EntityHandle entity, EntitySetHandle set )
313 : : {
314 : : int err;
315 : : PFX(_rmvEntFromSet)( mInstance, entity,set, &err );
316 : : return (Error)err;
317 : : }
318 : :
319 : : inline PFX(Base)::Error
320 : 203 : PFX(Base)::addEntArrToSet( const EntityHandle* entity_handles,
321 : : int entity_handles_size,
322 : : EntitySetHandle entity_set )
323 : : {
324 : : int err;
325 [ + - ]: 203 : PFX(_addEntArrToSet)( mInstance, entity_handles, entity_handles_size, entity_set, &err );
326 : 203 : return (Error)err;
327 : : }
328 : :
329 : : inline PFX(Base)::Error
330 : : PFX(Base)::rmvEntArrFromSet( const EntityHandle* entity_handles,
331 : : int entity_handles_size,
332 : : EntitySetHandle entity_set )
333 : : {
334 : : int err;
335 : : PFX(_rmvEntArrFromSet)( mInstance, entity_handles, entity_handles_size, entity_set, &err );
336 : : return (Error)err;
337 : : }
338 : :
339 : : inline PFX(Base)::Error
340 : 0 : PFX(Base)::addEntSet( EntitySetHandle to_add, EntitySetHandle add_to )
341 : : {
342 : : int err;
343 [ # # ]: 0 : PFX(_addEntSet)( mInstance, to_add, add_to, &err );
344 : 0 : return (Error)err;
345 : : }
346 : :
347 : : inline PFX(Base)::Error
348 : : PFX(Base)::rmvEntSet( EntitySetHandle to_rmv, EntitySetHandle rmv_from )
349 : : {
350 : : int err;
351 : : PFX(_rmvEntSet)( mInstance, to_rmv, rmv_from, &err );
352 : : return (Error)err;
353 : : }
354 : :
355 : : inline PFX(Base)::Error
356 : : PFX(Base)::isEntContained( EntitySetHandle set, EntityHandle ent, bool& contained_out ) const
357 : : {
358 : : int err, result;
359 : : PFX(_isEntContained)( mInstance, set, ent, &result, &err );
360 : : contained_out = (result != 0);
361 : : return (Error)err;
362 : : }
363 : :
364 : : inline PFX(Base)::Error
365 : : PFX(Base)::isEntArrContained( EntitySetHandle containing_set,
366 : : const EntityHandle* entity_handles,
367 : : int num_entity_handles,
368 : : bool* is_contained_out ) const
369 : : {
370 : : int err, *ptr = 0, alloc = 0, size = 0;
371 : : PFX(_isEntArrContained)( mInstance, containing_set,
372 : : entity_handles, num_entity_handles,
373 : : &ptr, &alloc, &size, &err );
374 : : if (iBase_SUCCESS != err)
375 : : return (Error)err;
376 : : for (int i = 0; i < num_entity_handles; ++i)
377 : : is_contained_out[i] = (ptr[i] != 0);
378 : : free(ptr);
379 : : return iBase_SUCCESS;
380 : : }
381 : :
382 : : inline PFX(Base)::Error
383 : : PFX(Base)::isEntSetContained( EntitySetHandle containing_set,
384 : : EntitySetHandle contained_set,
385 : : bool& contained_out ) const
386 : : {
387 : : int err, result;
388 : : PFX(_isEntSetContained)( mInstance, containing_set, contained_set, &result, &err );
389 : : contained_out = (result != 0);
390 : : return (Error)err;
391 : : }
392 : :
393 : : inline PFX(Base)::Error
394 : : PFX(Base)::addPrntChld( EntitySetHandle parent, EntitySetHandle child )
395 : : {
396 : : int err;
397 : : PFX(_addPrntChld)( mInstance, parent, child, &err );
398 : : return (Error)err;
399 : : }
400 : :
401 : : inline PFX(Base)::Error
402 : : PFX(Base)::rmvPrntChld( EntitySetHandle parent, EntitySetHandle child )
403 : : {
404 : : int err;
405 : : PFX(_rmvPrntChld)( mInstance, parent, child, &err );
406 : : return (Error)err;
407 : : }
408 : :
409 : : inline PFX(Base)::Error
410 : : PFX(Base)::isChildOf( EntitySetHandle parent, EntitySetHandle child, bool& is_child_out ) const
411 : : {
412 : : int err, result;
413 : : PFX(_isChildOf)( mInstance, parent, child, &result, &err );
414 : : is_child_out = (result != 0);
415 : : return (Error)err;
416 : : }
417 : :
418 : : inline PFX(Base)::Error
419 : : PFX(Base)::getNumChld( EntitySetHandle parent, int num_hops, int& num_child_out ) const
420 : : {
421 : : int err;
422 : : PFX(_getNumChld)( mInstance, parent, num_hops, &num_child_out, &err );
423 : : return (Error)err;
424 : : }
425 : :
426 : : inline PFX(Base)::Error
427 : 207 : PFX(Base)::getNumPrnt( EntitySetHandle child, int num_hops, int& num_parent_out ) const
428 : : {
429 : : int err;
430 [ + - ]: 207 : PFX(_getNumPrnt)( mInstance, child, num_hops, &num_parent_out, &err );
431 : 207 : return (Error)err;
432 : : }
433 : :
434 : : inline PFX(Base)::Error
435 : : PFX(Base)::getChldn( EntitySetHandle parent, int num_hops,
436 : : std::vector<EntitySetHandle>& children_out ) const
437 : : {
438 : : int err, count;
439 : : PFX(_getNumChld)( mInstance, parent, num_hops, &count, &err );
440 : : if (iBase_SUCCESS != err)
441 : : return (Error)err;
442 : : children_out.resize(count);
443 : : int alloc = children_out.size(), size;
444 : : EntitySetHandle* ptr = &children_out[0];
445 : : PFX(_getEntSets)( mInstance, parent, num_hops, &ptr, &alloc, &size, &err );
446 : : return (Error)err;
447 : : }
448 : :
449 : : inline PFX(Base)::Error
450 : 142 : PFX(Base)::getPrnts( EntitySetHandle child, int num_hops,
451 : : std::vector<EntitySetHandle>& parents_out ) const
452 : : {
453 : : int err, count;
454 [ + - ]: 142 : PFX(_getNumPrnt)( mInstance, child, num_hops, &count, &err );
455 [ - + ]: 142 : if (iBase_SUCCESS != err)
456 : 0 : return (Error)err;
457 [ + - ]: 142 : parents_out.resize(count);
458 : 142 : int alloc = parents_out.size(), size;
459 [ + - ]: 142 : EntitySetHandle* ptr = &parents_out[0];
460 [ + - ]: 142 : PFX(_getEntSets)( mInstance, child, num_hops, &ptr, &alloc, &size, &err );
461 : 142 : return (Error)err;
462 : : }
463 : :
464 : :
465 : : inline PFX(Base)::Error
466 : : PFX(Base)::subtract( EntitySetHandle set1, EntitySetHandle set2,
467 : : EntitySetHandle& result_set_out )
468 : : {
469 : : int err;
470 : : PFX(_subtract)( mInstance, set1, set1, &result_set_out, &err );
471 : : return (Error)err;
472 : : }
473 : :
474 : : inline PFX(Base)::Error
475 : : PFX(Base)::intersect( EntitySetHandle set1, EntitySetHandle set2,
476 : : EntitySetHandle& result_set_out )
477 : : {
478 : : int err;
479 : : PFX(_intersect)( mInstance, set1, set1, &result_set_out, &err );
480 : : return (Error)err;
481 : : }
482 : :
483 : : inline PFX(Base)::Error
484 : 0 : PFX(Base)::unite( EntitySetHandle set1, EntitySetHandle set2,
485 : : EntitySetHandle& result_set_out )
486 : : {
487 : : int err;
488 [ # # ]: 0 : PFX(_unite)( mInstance, set1, set1, &result_set_out, &err );
489 : 0 : return (Error)err;
490 : : }
491 : :
492 : :
493 : : inline PFX(Base)::Error
494 : 281 : PFX(Base)::createTag( const char* tag_name,
495 : : int tag_num_type_values,
496 : : TagValueType tag_type,
497 : : TagHandle& tag_handle_out )
498 : : {
499 : : int err;
500 : : PFX(_createTag)( mInstance, tag_name, tag_num_type_values, tag_type,
501 [ + - ]: 281 : &tag_handle_out, &err, strlen(tag_name) );
502 : 281 : return (Error)err;
503 : : }
504 : :
505 : :
506 : : inline PFX(Base)::Error
507 : 20 : PFX(Base)::destroyTag( TagHandle tag_handle, bool forced )
508 : : {
509 : : int err;
510 [ + - ]: 20 : PFX(_destroyTag)( mInstance, tag_handle, forced, &err );
511 : 20 : return (Error)err;
512 : : }
513 : :
514 : : inline PFX(Base)::Error
515 : : PFX(Base)::getTagName( TagHandle tag_handle, std::string& name_out ) const
516 : : {
517 : : int err;
518 : : char buffer[1024];
519 : : memset( buffer, 0, sizeof(buffer) );
520 : : PFX(_getTagName)( mInstance, tag_handle, buffer, &err, sizeof(buffer) );
521 : : name_out = buffer;
522 : : return (Error)err;
523 : : }
524 : :
525 : : inline PFX(Base)::Error
526 : 2 : PFX(Base)::getTagSizeValues( TagHandle tag_handle, int& size_out ) const
527 : : {
528 : : int err;
529 [ + - ]: 2 : PFX(_getTagSizeValues)( mInstance, tag_handle, &size_out, &err );
530 : 2 : return (Error)err;
531 : : }
532 : :
533 : : inline PFX(Base)::Error
534 : 4 : PFX(Base)::getTagSizeBytes( TagHandle tag_handle, int& size_out ) const
535 : : {
536 : : int err;
537 [ + - ]: 4 : PFX(_getTagSizeBytes)( mInstance, tag_handle, &size_out, &err );
538 : 4 : return (Error)err;
539 : : }
540 : :
541 : : inline PFX(Base)::Error
542 : 98 : PFX(Base)::getTagHandle( const char* name, TagHandle& handle_out ) const
543 : : {
544 : : int err;
545 [ + - ]: 98 : PFX(_getTagHandle)( mInstance, name, &handle_out, &err, strlen(name) );
546 : 98 : return (Error)err;
547 : : }
548 : :
549 : : inline PFX(Base)::Error
550 : 2 : PFX(Base)::getTagType( TagHandle tag_handle, TagValueType& type_out ) const
551 : : {
552 : : int err, result;
553 [ + - ]: 2 : PFX(_getTagType)( mInstance, tag_handle, &result, &err );
554 : 2 : type_out = (TagValueType)result;
555 : 2 : return (Error)err;
556 : : }
557 : :
558 : :
559 : : inline PFX(Base)::Error
560 : 241 : PFX(Base)::setEntSetData( EntitySetHandle set_handle,
561 : : TagHandle tag_handle,
562 : : const void* tag_value )
563 : : {
564 : 241 : int err, size = 1;
565 [ + - ]: 241 : PFX(_getTagSizeBytes)( mInstance, tag_handle, &size, &err );
566 : : PFX(_setEntSetData)( mInstance, set_handle, tag_handle,
567 [ + - ]: 241 : (const char*)tag_value, size, &err);
568 : 241 : return (Error)err;
569 : : }
570 : :
571 : : inline PFX(Base)::Error
572 : : PFX(Base)::setEntSetIntData( EntitySetHandle set_handle,
573 : : TagHandle tag_handle,
574 : : int value )
575 : : {
576 : : int err;
577 : : PFX(_setEntSetIntData)( mInstance, set_handle, tag_handle, value, &err );
578 : : return (Error)err;
579 : : }
580 : :
581 : : inline PFX(Base)::Error
582 : : PFX(Base)::setEntSetDblData( EntitySetHandle set_handle,
583 : : TagHandle tag_handle,
584 : : double value )
585 : : {
586 : : int err;
587 : : PFX(_setEntSetDblData)( mInstance, set_handle, tag_handle, value, &err );
588 : : return (Error)err;
589 : : }
590 : :
591 : : inline PFX(Base)::Error
592 : 8 : PFX(Base)::setEntSetEHData( EntitySetHandle set_handle,
593 : : TagHandle tag_handle,
594 : : EntityHandle value )
595 : :
596 : : {
597 : : int err;
598 [ + - ]: 8 : PFX(_setEntSetEHData)( mInstance, set_handle, tag_handle, value, &err );
599 : 8 : return (Error)err;
600 : : }
601 : :
602 : : inline PFX(Base)::Error
603 : 20 : PFX(Base)::setEntSetESHData( EntitySetHandle set_handle,
604 : : TagHandle tag_handle,
605 : : EntitySetHandle value )
606 : :
607 : : {
608 : : int err;
609 [ + - ]: 20 : PFX(_setEntSetESHData)( mInstance, set_handle, tag_handle, value, &err );
610 : 20 : return (Error)err;
611 : : }
612 : :
613 : : inline PFX(Base)::Error
614 : 8 : PFX(Base)::getEntSetData( EntitySetHandle set_handle,
615 : : TagHandle tag_handle,
616 : : void* tag_value_out ) const
617 : : {
618 : 8 : int err, alloc = std::numeric_limits<int>::max(), size;
619 : : PFX(_getEntSetData)( mInstance, set_handle, tag_handle,
620 [ + - ]: 8 : &tag_value_out, &alloc, &size, &err);
621 : 8 : return (Error)err;
622 : : }
623 : :
624 : : inline PFX(Base)::Error
625 : : PFX(Base)::getEntSetIntData( EntitySetHandle set_handle,
626 : : TagHandle tag_handle,
627 : : int& value_out ) const
628 : : {
629 : : int err;
630 : : PFX(_getEntSetIntData)( mInstance, set_handle, tag_handle, &value_out, &err );
631 : : return (Error)err;
632 : : }
633 : :
634 : : inline PFX(Base)::Error
635 : : PFX(Base)::getEntSetDblData( EntitySetHandle set_handle,
636 : : TagHandle tag_handle,
637 : : double& value_out ) const
638 : : {
639 : : int err;
640 : : PFX(_getEntSetDblData)( mInstance, set_handle, tag_handle, &value_out, &err );
641 : : return (Error)err;
642 : : }
643 : :
644 : : inline PFX(Base)::Error
645 : 18 : PFX(Base)::getEntSetEHData( EntitySetHandle set_handle,
646 : : TagHandle tag_handle,
647 : : EntityHandle& value_out ) const
648 : :
649 : : {
650 : : int err;
651 [ + - ]: 18 : PFX(_getEntSetEHData)( mInstance, set_handle, tag_handle, &value_out, &err );
652 : 18 : return (Error)err;
653 : : }
654 : :
655 : : inline PFX(Base)::Error
656 : 42 : PFX(Base)::getEntSetESHData( EntitySetHandle set_handle,
657 : : TagHandle tag_handle,
658 : : EntitySetHandle& value_out ) const
659 : :
660 : : {
661 : : int err;
662 [ + - ]: 42 : PFX(_getEntSetESHData)( mInstance, set_handle, tag_handle, &value_out, &err );
663 : 42 : return (Error)err;
664 : : }
665 : :
666 : : inline PFX(Base)::Error
667 : : PFX(Base)::getAllEntSetTags( EntitySetHandle set,
668 : : std::vector<TagHandle>& tags_out ) const
669 : : {
670 : : if (tags_out.capacity() == 0)
671 : : tags_out.resize( 32 );
672 : : else
673 : : tags_out.resize( tags_out.capacity() );
674 : :
675 : : int err, alloc = tags_out.size(), size = 0;
676 : : TagHandle* ptr = &tags_out[0];
677 : : PFX(_getAllEntSetTags)( mInstance, set, &ptr, &alloc, &size, &err );
678 : : tags_out.resize(size);
679 : :
680 : : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
681 : : alloc = tags_out.size();
682 : : ptr = &tags_out[0];
683 : : PFX(_getAllEntSetTags)( mInstance, set, &ptr, &alloc, &size, &err );
684 : : }
685 : :
686 : : return (Error)err;
687 : : }
688 : :
689 : : inline PFX(Base)::Error
690 : : PFX(Base)::getAllTags( EntityHandle entity,
691 : : std::vector<TagHandle>& tags_out ) const
692 : :
693 : : {
694 : : if (tags_out.capacity() == 0)
695 : : tags_out.resize( 32 );
696 : : else
697 : : tags_out.resize( tags_out.capacity() );
698 : :
699 : : int err, alloc = tags_out.size(), size = 0;
700 : : TagHandle* ptr = &tags_out[0];
701 : : PFX(_getAllTags)( mInstance, entity, &ptr, &alloc, &size, &err );
702 : : tags_out.resize(size);
703 : :
704 : : if (iBase_BAD_ARRAY_DIMENSION == err || iBase_BAD_ARRAY_SIZE == err) {
705 : : alloc = tags_out.size();
706 : : ptr = &tags_out[0];
707 : : PFX(_getAllTags)( mInstance, entity, &ptr, &alloc, &size, &err );
708 : : }
709 : :
710 : : return (Error)err;
711 : : }
712 : :
713 : : inline PFX(Base)::Error
714 : : PFX(Base)::rmvEntSetTag( EntitySetHandle set, TagHandle tag )
715 : : {
716 : : int err;
717 : : PFX(_rmvEntSetTag)( mInstance, set, tag, &err );
718 : : return (Error)err;
719 : : }
720 : :
721 : : inline PFX(Base)::Error
722 : : PFX(Base)::rmvTag( EntityHandle entity, TagHandle tag )
723 : : {
724 : : int err;
725 : : PFX(_rmvTag)( mInstance, entity, tag, &err );
726 : : return (Error)err;
727 : : }
728 : :
729 : : inline PFX(Base)::Error
730 : 110 : PFX(Base)::rmvArrTag( const EntityHandle* handles, int size, TagHandle tag )
731 : : {
732 : : int err;
733 [ + - ]: 110 : PFX(_rmvArrTag)( mInstance, handles, size, tag, &err );
734 : 110 : return (Error)err;
735 : : }
736 : :
737 : :
738 : : inline PFX(Base)::Error
739 : : PFX(Base)::getArrData( const EntityHandle* entity_handles,
740 : : int entity_handles_size,
741 : : TagHandle tag_handle,
742 : : void* tag_values_out ) const
743 : : {
744 : : int err, alloc = std::numeric_limits<int>::max(), size;
745 : : PFX(_getArrData)( mInstance, entity_handles, entity_handles_size, tag_handle,
746 : : &tag_values_out, &alloc, &size, &err);
747 : : return (Error)err;
748 : : }
749 : :
750 : : inline PFX(Base)::Error
751 : : PFX(Base)::getIntArrData( const EntityHandle* entity_handles,
752 : : int entity_handles_size,
753 : : TagHandle tag_handle,
754 : : int* tag_values_out ) const
755 : : {
756 : : int err, alloc = std::numeric_limits<int>::max(), size;
757 : : PFX(_getIntArrData)( mInstance, entity_handles, entity_handles_size, tag_handle,
758 : : &tag_values_out, &alloc, &size, &err);
759 : : return (Error)err;
760 : : }
761 : :
762 : : inline PFX(Base)::Error
763 : : PFX(Base)::getDblArrData( const EntityHandle* entity_handles,
764 : : int entity_handles_size,
765 : : TagHandle tag_handle,
766 : : double* tag_values_out ) const
767 : : {
768 : : int err, alloc = std::numeric_limits<int>::max(), size;
769 : : PFX(_getDblArrData)( mInstance, entity_handles, entity_handles_size, tag_handle,
770 : : &tag_values_out, &alloc, &size, &err);
771 : : return (Error)err;
772 : : }
773 : :
774 : : inline PFX(Base)::Error
775 : : PFX(Base)::getEHArrData( const EntityHandle* entity_handles,
776 : : int entity_handles_size,
777 : : TagHandle tag_handle,
778 : : EntityHandle* tag_values_out ) const
779 : :
780 : : {
781 : : int err, alloc = std::numeric_limits<int>::max(), size;
782 : : PFX(_getEHArrData)( mInstance, entity_handles, entity_handles_size, tag_handle,
783 : : &tag_values_out, &alloc, &size, &err);
784 : : return (Error)err;
785 : : }
786 : :
787 : : inline PFX(Base)::Error
788 : : PFX(Base)::getESHArrData( const EntityHandle* entity_handles,
789 : : int entity_handles_size,
790 : : TagHandle tag_handle,
791 : : EntitySetHandle* tag_values_out ) const
792 : :
793 : : {
794 : : int err, alloc = std::numeric_limits<int>::max(), size;
795 : : PFX(_getESHArrData)( mInstance, entity_handles, entity_handles_size, tag_handle,
796 : : &tag_values_out, &alloc, &size, &err);
797 : : return (Error)err;
798 : : }
799 : :
800 : : inline PFX(Base)::Error
801 : : PFX(Base)::setArrData( const EntityHandle* entity_handles,
802 : : int entity_handles_size,
803 : : TagHandle tag_handle,
804 : : const void* tag_values )
805 : : {
806 : : int err, size = 1;
807 : : PFX(_getTagSizeBytes)( mInstance, tag_handle, &size, &err );
808 : : PFX(_setArrData)( mInstance, entity_handles, entity_handles_size, tag_handle,
809 : : (const char*)tag_values, size*entity_handles_size,
810 : : &err );
811 : : return (Error)err;
812 : : }
813 : :
814 : : inline PFX(Base)::Error
815 : 41 : PFX(Base)::setIntArrData( const EntityHandle* entity_handles,
816 : : int entity_handles_size,
817 : : TagHandle tag_handle,
818 : : const int* tag_values )
819 : : {
820 : 41 : int err, size = 1;
821 [ + - ]: 41 : PFX(_getTagSizeValues)( mInstance, tag_handle, &size, &err );
822 : : PFX(_setIntArrData)( mInstance, entity_handles, entity_handles_size, tag_handle,
823 [ + - ]: 41 : tag_values, size*entity_handles_size, &err );
824 : 41 : return (Error)err;
825 : : }
826 : :
827 : : inline PFX(Base)::Error
828 : 6 : PFX(Base)::setDblArrData( const EntityHandle* entity_handles,
829 : : int entity_handles_size,
830 : : TagHandle tag_handle,
831 : : const double* tag_values )
832 : : {
833 : 6 : int err, size = 1;
834 [ + - ]: 6 : PFX(_getTagSizeValues)( mInstance, tag_handle, &size, &err );
835 : : PFX(_setDblArrData)( mInstance, entity_handles, entity_handles_size, tag_handle,
836 [ + - ]: 6 : tag_values, size*entity_handles_size, &err );
837 : 6 : return (Error)err;
838 : : }
839 : :
840 : : inline PFX(Base)::Error
841 : 17 : PFX(Base)::setEHArrData( const EntityHandle* entity_handles,
842 : : int entity_handles_size,
843 : : TagHandle tag_handle,
844 : : const EntityHandle* tag_values )
845 : : {
846 : 17 : int err, size = 1;
847 [ + - ]: 17 : PFX(_getTagSizeValues)( mInstance, tag_handle, &size, &err );
848 : : PFX(_setEHArrData)( mInstance, entity_handles, entity_handles_size, tag_handle,
849 [ + - ]: 17 : tag_values, size*entity_handles_size, &err );
850 : 17 : return (Error)err;
851 : : }
852 : :
853 : : inline PFX(Base)::Error
854 : : PFX(Base)::setESHArrData( const EntityHandle* entity_handles,
855 : : int entity_handles_size,
856 : : TagHandle tag_handle,
857 : : const EntitySetHandle* tag_values )
858 : : {
859 : : int err, size = 1;
860 : : PFX(_getTagSizeValues)( mInstance, tag_handle, &size, &err );
861 : : PFX(_setESHArrData)( mInstance, entity_handles, entity_handles_size, tag_handle,
862 : : tag_values, size*entity_handles_size, &err );
863 : : return (Error)err;
864 : : }
865 : :
866 : :
867 : :
868 : : inline PFX(Base)::Error
869 : : PFX(Base)::setData( EntityHandle entity_handle,
870 : : TagHandle tag_handle,
871 : : const void* tag_value )
872 : : {
873 : : int err, size = 1;
874 : : PFX(_getTagSizeBytes)( mInstance, tag_handle, &size, &err );
875 : : PFX(_setData)( mInstance, entity_handle, tag_handle,
876 : : (const char*)tag_value, size, &err);
877 : : return (Error)err;
878 : : return (Error)err;
879 : : }
880 : :
881 : : inline PFX(Base)::Error
882 : 38965 : PFX(Base)::setIntData( EntityHandle entity_handle,
883 : : TagHandle tag_handle,
884 : : int value )
885 : : {
886 : : int err;
887 [ + - ]: 38965 : PFX(_setIntData)( mInstance, entity_handle, tag_handle, value, &err );
888 : 38965 : return (Error)err;
889 : : }
890 : :
891 : : inline PFX(Base)::Error
892 : : PFX(Base)::setDblData( EntityHandle entity_handle,
893 : : TagHandle tag_handle,
894 : : double value )
895 : : {
896 : : int err;
897 : : PFX(_setDblData)( mInstance, entity_handle, tag_handle, value, &err );
898 : : return (Error)err;
899 : : }
900 : :
901 : : inline PFX(Base)::Error
902 : 22 : PFX(Base)::setEHData( EntityHandle entity_handle,
903 : : TagHandle tag_handle,
904 : : EntityHandle value )
905 : :
906 : : {
907 : : int err;
908 [ + - ]: 22 : PFX(_setEHData)( mInstance, entity_handle, tag_handle, value, &err );
909 : 22 : return (Error)err;
910 : : }
911 : :
912 : : inline PFX(Base)::Error
913 : : PFX(Base)::setESHData( EntityHandle entity_handle,
914 : : TagHandle tag_handle,
915 : : EntitySetHandle value )
916 : :
917 : : {
918 : : int err;
919 : : PFX(_setESHData)( mInstance, entity_handle, tag_handle, value, &err );
920 : : return (Error)err;
921 : : }
922 : :
923 : : inline PFX(Base)::Error
924 : 0 : PFX(Base)::getData( EntityHandle entity_handle,
925 : : TagHandle tag_handle,
926 : : void* tag_value_out ) const
927 : : {
928 : 0 : int err, alloc = std::numeric_limits<int>::max(), size;
929 : : PFX(_getData)( mInstance, entity_handle, tag_handle,
930 [ # # ]: 0 : &tag_value_out, &alloc, &size, &err);
931 : 0 : return (Error)err;
932 : : }
933 : :
934 : : inline PFX(Base)::Error
935 : 5094 : PFX(Base)::getIntData( EntityHandle entity_handle,
936 : : TagHandle tag_handle,
937 : : int& value_out ) const
938 : : {
939 : : int err;
940 [ + - ]: 5094 : PFX(_getIntData)( mInstance, entity_handle, tag_handle, &value_out, &err );
941 : 5094 : return (Error)err;
942 : : }
943 : :
944 : : inline PFX(Base)::Error
945 : : PFX(Base)::getDblData( EntityHandle entity_handle,
946 : : TagHandle tag_handle,
947 : : double& value_out ) const
948 : : {
949 : : int err;
950 : : PFX(_getDblData)( mInstance, entity_handle, tag_handle, &value_out, &err );
951 : : return (Error)err;
952 : : }
953 : :
954 : : inline PFX(Base)::Error
955 : 103 : PFX(Base)::getEHData( EntityHandle entity_handle,
956 : : TagHandle tag_handle,
957 : : EntityHandle& value_out ) const
958 : : {
959 : : int err;
960 [ + - ]: 103 : PFX(_getEHData)( mInstance, entity_handle, tag_handle, &value_out, &err );
961 : 103 : return (Error)err;
962 : : }
963 : :
964 : : inline PFX(Base)::Error
965 : : PFX(Base)::getESHData( EntityHandle entity_handle,
966 : : TagHandle tag_handle,
967 : : EntitySetHandle& value_out ) const
968 : : {
969 : : int err;
970 : : PFX(_getESHData)( mInstance, entity_handle, tag_handle, &value_out, &err );
971 : : return (Error)err;
972 : : }
973 : :
974 : : #undef PFX__
975 : : #undef PFX_
976 : : #undef PFX
|
