LCOV - code coverage report
Current view: top level - data/include/set - data_visible_set.inl (source / functions) Coverage Total Hit
Test: crystal-facet-uml_v1.63.2_covts Lines: 95.5 % 220 210
Test Date: 2025-05-01 10:10:14 Functions: 100.0 % 33 33

            Line data    Source code
       1              : /* File: data_visible_set.inl; Copyright and License: see below */
       2              : 
       3              : #include "u8/u8_log.h"
       4              : #include <assert.h>
       5              : 
       6              : /* ================================ diagram ================================ */
       7              : 
       8          772 : static inline const data_diagram_t *data_visible_set_get_diagram_const ( const data_visible_set_t *this_ )
       9              : {
      10          772 :     return &((*this_).diagram);
      11              : }
      12              : 
      13            2 : static inline data_diagram_t *data_visible_set_get_diagram_ptr ( data_visible_set_t *this_ )
      14              : {
      15            2 :     return &((*this_).diagram);
      16              : }
      17              : 
      18            1 : static inline u8_error_t data_visible_set_replace_diagram( data_visible_set_t *this_, const data_diagram_t *new_diagram )
      19              : {
      20            1 :     assert( NULL != new_diagram );
      21            1 :     data_diagram_replace( &((*this_).diagram), new_diagram );
      22            1 :     return U8_ERROR_NONE;
      23              : }
      24              : 
      25              : /* ================================ classifiers ================================ */
      26              : 
      27           40 : static inline uint32_t data_visible_set_get_visible_classifier_count ( const data_visible_set_t *this_ )
      28              : {
      29           40 :     return (*this_).visible_classifier_count;
      30              : }
      31              : 
      32         2277 : static inline const data_visible_classifier_t *data_visible_set_get_visible_classifier_const ( const data_visible_set_t *this_, uint32_t index )
      33              : {
      34         2277 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
      35              : 
      36              :     const data_visible_classifier_t *result;
      37         2277 :     if ( index < (*this_).visible_classifier_count )
      38              :     {
      39         2277 :         result = &((*this_).visible_classifiers[index]);
      40              :     }
      41              :     else
      42              :     {
      43            0 :         result = NULL;
      44            0 :         U8_LOG_ERROR_INT( "index out of bounds (>=(*this_).visible_classifier_count)", index );
      45              :     }
      46              : 
      47         2277 :     return result;
      48              : }
      49              : 
      50              : static inline data_visible_classifier_t *data_visible_set_get_visible_classifier_ptr ( data_visible_set_t *this_, uint32_t index )
      51              : {
      52              :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
      53              : 
      54              :     data_visible_classifier_t *result;
      55              :     if ( index < (*this_).visible_classifier_count )
      56              :     {
      57              :         result = &((*this_).visible_classifiers[index]);
      58              :     }
      59              :     else
      60              :     {
      61              :         result = NULL;
      62              :         U8_LOG_ERROR_INT( "index out of bounds (>=(*this_).visible_classifier_count)", index );
      63              :     }
      64              : 
      65              :     return result;
      66              : }
      67              : 
      68            1 : static inline const data_visible_classifier_t *data_visible_set_get_visible_classifier_by_id_const ( const data_visible_set_t *this_, data_row_t diagramelement_id )
      69              : {
      70            1 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
      71            1 :     const data_visible_classifier_t *result = NULL;
      72              : 
      73              :     /* iterate over all visible classifiers */
      74            2 :     for ( uint32_t index = 0; index < (*this_).visible_classifier_count; index ++ )
      75              :     {
      76              :         const data_visible_classifier_t *visible_classifier;
      77            2 :         visible_classifier = &((*this_).visible_classifiers[index]);
      78            2 :         assert ( data_visible_classifier_is_valid( visible_classifier ) );
      79              : 
      80              :         const data_diagramelement_t *diagramelement;
      81            2 :         diagramelement = data_visible_classifier_get_diagramelement_const( visible_classifier );
      82            2 :         if ( data_diagramelement_get_row_id( diagramelement ) == diagramelement_id )
      83              :         {
      84            1 :             result = visible_classifier;
      85            1 :             break;
      86              :         }
      87              :     }
      88              : 
      89            1 :     return result;
      90              : }
      91              : 
      92            1 : static inline data_visible_classifier_t *data_visible_set_get_visible_classifier_by_id_ptr ( data_visible_set_t *this_, data_row_t diagramelement_id )
      93              : {
      94            1 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
      95            1 :     data_visible_classifier_t *result = NULL;
      96              : 
      97              :     /* iterate over all visible classifiers */
      98            1 :     for ( uint32_t index = 0; index < (*this_).visible_classifier_count; index ++ )
      99              :     {
     100              :         data_visible_classifier_t *visible_classifier;
     101            1 :         visible_classifier = &((*this_).visible_classifiers[index]);
     102            1 :         assert ( data_visible_classifier_is_valid( visible_classifier ) );
     103              : 
     104              :         data_diagramelement_t *diagramelement;
     105            1 :         diagramelement = data_visible_classifier_get_diagramelement_ptr( visible_classifier );
     106            1 :         if ( data_diagramelement_get_row_id( diagramelement ) == diagramelement_id )
     107              :         {
     108            1 :             result = visible_classifier;
     109            1 :             break;
     110              :         }
     111              :     }
     112              : 
     113            1 :     return result;
     114              : }
     115              : 
     116         1206 : static inline const data_classifier_t *data_visible_set_get_classifier_by_id_const ( const data_visible_set_t *this_, data_row_t row_id )
     117              : {
     118         1206 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     119         1206 :     const data_classifier_t *result = NULL;
     120              : 
     121        59826 :     for ( int index = 0; index < (*this_).visible_classifier_count; index ++ )
     122              :     {
     123              :         const data_visible_classifier_t *visible_classifier;
     124        59791 :         visible_classifier = &((*this_).visible_classifiers[index]);
     125        59791 :         assert ( data_visible_classifier_is_valid( visible_classifier ) );
     126              : 
     127              :         const data_classifier_t *probe;
     128        59791 :         probe = data_visible_classifier_get_classifier_const( visible_classifier );
     129        59791 :         if ( row_id == data_classifier_get_row_id( probe ) )
     130              :         {
     131         1171 :             result = probe;
     132         1171 :             break;
     133              :         }
     134              :     }
     135              : 
     136         1206 :     return result;
     137              : }
     138              : 
     139            1 : static inline data_classifier_t *data_visible_set_get_classifier_by_id_ptr ( data_visible_set_t *this_, data_row_t row_id )
     140              : {
     141            1 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     142            1 :     data_classifier_t *result = NULL;
     143              : 
     144            1 :     for ( int index = 0; index < (*this_).visible_classifier_count; index ++ )
     145              :     {
     146              :         data_visible_classifier_t *visible_classifier;
     147            1 :         visible_classifier = &((*this_).visible_classifiers[index]);
     148            1 :         assert ( data_visible_classifier_is_valid( visible_classifier ) );
     149              : 
     150              :         data_classifier_t *probe;
     151            1 :         probe = data_visible_classifier_get_classifier_ptr( visible_classifier );
     152            1 :         if ( row_id == data_classifier_get_row_id( probe ) )
     153              :         {
     154            1 :             result = probe;
     155            1 :             break;
     156              :         }
     157              :     }
     158              : 
     159            1 :     return result;
     160              : }
     161              : 
     162          772 : static inline int32_t data_visible_set_get_classifier_index ( const data_visible_set_t *this_, data_row_t row_id )
     163              : {
     164          772 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     165          772 :     int32_t result = -1;
     166              : 
     167         1158 :     for ( int index = 0; index < (*this_).visible_classifier_count; index ++ )
     168              :     {
     169              :         const data_classifier_t *probe;
     170         1158 :         probe = data_visible_classifier_get_classifier_const( &((*this_).visible_classifiers[index]) );
     171         1158 :         if ( row_id == data_classifier_get_row_id( probe ) )
     172              :         {
     173          772 :             result = index;
     174          772 :             break;
     175              :         }
     176              :     }
     177              : 
     178          772 :     return result;
     179              : }
     180              : 
     181            1 : static inline uint32_t data_visible_set_get_classifier_index_from_pointer ( const data_visible_set_t *this_,
     182              :                                                                             const data_visible_classifier_t *vis_classifier_ptr )
     183              : {
     184            1 :     assert ( NULL != vis_classifier_ptr );  /* input parameters test */
     185            1 :     assert ( vis_classifier_ptr >= &((*this_).visible_classifiers[0]) );  /* input parameters test */
     186            1 :     assert ( vis_classifier_ptr < &((*this_).visible_classifiers[DATA_VISIBLE_SET_MAX_CLASSIFIERS]) );  /* input parameters test */
     187              :     assert ( 3 == &((*this_).visible_classifiers[3]) - (*this_).visible_classifiers );  /* compiler test */
     188            1 :     return ( vis_classifier_ptr - (*this_).visible_classifiers );
     189              : }
     190              : 
     191          129 : static inline u8_error_t data_visible_set_append_classifier( data_visible_set_t *this_, const data_visible_classifier_t *new_classifier )
     192              : {
     193          129 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     194          129 :     assert( NULL != new_classifier );
     195          129 :     u8_error_t result = U8_ERROR_NONE;
     196              :     
     197          129 :     const uint32_t new_index = (*this_).visible_classifier_count;
     198          129 :     if ( new_index < DATA_VISIBLE_SET_MAX_CLASSIFIERS )
     199              :     {
     200          128 :         data_visible_classifier_copy( &((*this_).visible_classifiers[new_index]), new_classifier );
     201          128 :         (*this_).visible_classifier_count ++;
     202              :     }
     203              :     else
     204              :     {
     205            1 :         result = U8_ERROR_ARRAY_BUFFER_EXCEEDED;
     206              :     }
     207              :     
     208          129 :     return result;
     209              : }
     210              : 
     211              : /* ================================ features ================================ */
     212              : 
     213           14 : static inline uint32_t data_visible_set_get_feature_count ( const data_visible_set_t *this_ )
     214              : {
     215           14 :     return (*this_).feature_count;
     216              : }
     217              : 
     218          559 : static inline const data_feature_t *data_visible_set_get_feature_const ( const data_visible_set_t *this_, uint32_t index )
     219              : {
     220          559 :     assert( (*this_).feature_count <= DATA_VISIBLE_SET_MAX_FEATURES );
     221              : 
     222              :     const data_feature_t *result;
     223          559 :     if ( index < (*this_).feature_count )
     224              :     {
     225          559 :         result = &((*this_).features[index]);
     226              :     }
     227              :     else
     228              :     {
     229            0 :         result = NULL;
     230            0 :         U8_LOG_ERROR_INT( "index out of bounds (>=(*this_).feature_count)", index );
     231              :     }
     232              : 
     233          559 :     return result;
     234              : }
     235              : 
     236            2 : static inline data_feature_t *data_visible_set_get_feature_ptr ( data_visible_set_t *this_, uint32_t index )
     237              : {
     238            2 :     assert( (*this_).feature_count <= DATA_VISIBLE_SET_MAX_FEATURES );
     239              : 
     240              :     data_feature_t *result;
     241            2 :     if ( index < (*this_).feature_count )
     242              :     {
     243            2 :         result = &((*this_).features[index]);
     244              :     }
     245              :     else
     246              :     {
     247            0 :         result = NULL;
     248            0 :         U8_LOG_ERROR_INT( "index out of bounds (>=(*this_).feature_count)", index );
     249              :     }
     250              : 
     251            2 :     return result;
     252              : }
     253              : 
     254         1182 : static inline const data_feature_t *data_visible_set_get_feature_by_id_const ( const data_visible_set_t *this_, data_row_t row_id )
     255              : {
     256         1182 :     assert( (*this_).feature_count <= DATA_VISIBLE_SET_MAX_FEATURES );
     257         1182 :     const data_feature_t *result = NULL;
     258              : 
     259       238259 :     for ( int index = 0; index < (*this_).feature_count; index ++ )
     260              :     {
     261              :         const data_feature_t *probe;
     262       237428 :         probe = &((*this_).features[index]);
     263       237428 :         if ( row_id == data_feature_get_row_id( probe ) )
     264              :         {
     265          351 :             result = probe;
     266          351 :             break;
     267              :         }
     268              :     }
     269              : 
     270         1182 :     return result;
     271              : }
     272              : 
     273            1 : static inline data_feature_t *data_visible_set_get_feature_by_id_ptr ( data_visible_set_t *this_, data_row_t row_id )
     274              : {
     275            1 :     assert( (*this_).feature_count <= DATA_VISIBLE_SET_MAX_FEATURES );
     276            1 :     data_feature_t *result = NULL;
     277              : 
     278            1 :     for ( int index = 0; index < (*this_).feature_count; index ++ )
     279              :     {
     280              :         data_feature_t *probe;
     281            1 :         probe = &((*this_).features[index]);
     282            1 :         if ( row_id == data_feature_get_row_id( probe ) )
     283              :         {
     284            1 :             result = probe;
     285            1 :             break;
     286              :         }
     287              :     }
     288              : 
     289            1 :     return result;
     290              : }
     291              : 
     292            1 : static inline data_feature_t *data_visible_set_get_feature_list_ptr ( data_visible_set_t *this_ )
     293              : {
     294            1 :     assert( (*this_).feature_count <= DATA_VISIBLE_SET_MAX_FEATURES );
     295            1 :     return (*this_).features;
     296              : }
     297              : 
     298          257 : static inline u8_error_t data_visible_set_append_feature( data_visible_set_t *this_, const data_feature_t *new_feature )
     299              : {
     300          257 :     assert( (*this_).feature_count <= DATA_VISIBLE_SET_MAX_FEATURES );
     301          257 :     assert( NULL != new_feature );
     302          257 :     u8_error_t result = U8_ERROR_NONE;
     303              :     
     304          257 :     const uint32_t new_index = (*this_).feature_count;
     305          257 :     if ( new_index < DATA_VISIBLE_SET_MAX_FEATURES )
     306              :     {
     307          256 :         data_feature_copy( &((*this_).features[new_index]), new_feature );
     308          256 :         (*this_).feature_count ++;
     309              :     }
     310              :     else
     311              :     {
     312            1 :         result = U8_ERROR_ARRAY_BUFFER_EXCEEDED;
     313              :     }
     314              :     
     315          257 :     return result;
     316              : }
     317              : 
     318              : /* ================================ relationships ================================ */
     319              : 
     320           14 : static inline uint32_t data_visible_set_get_relationship_count ( const data_visible_set_t *this_ )
     321              : {
     322           14 :     return (*this_).relationship_count;
     323              : }
     324              : 
     325          805 : static inline const data_relationship_t *data_visible_set_get_relationship_const ( const data_visible_set_t *this_, uint32_t index )
     326              : {
     327          805 :     assert( (*this_).relationship_count <= DATA_VISIBLE_SET_MAX_RELATIONSHIPS );
     328              : 
     329              :     const data_relationship_t *result;
     330          805 :     if ( index < (*this_).relationship_count )
     331              :     {
     332          805 :         result = &((*this_).relationships[index]);
     333              :     }
     334              :     else
     335              :     {
     336            0 :         result = NULL;
     337            0 :         U8_LOG_ERROR_INT( "index out of bounds (>=(*this_).relationship_count)", index );
     338              :     }
     339              : 
     340          805 :     return result;
     341              : }
     342              : 
     343            5 : static inline data_relationship_t *data_visible_set_get_relationship_ptr ( data_visible_set_t *this_, uint32_t index )
     344              : {
     345            5 :     assert( (*this_).relationship_count <= DATA_VISIBLE_SET_MAX_RELATIONSHIPS );
     346              : 
     347              :     data_relationship_t *result;
     348            5 :     if ( index < (*this_).relationship_count )
     349              :     {
     350            5 :         result = &((*this_).relationships[index]);
     351              :     }
     352              :     else
     353              :     {
     354            0 :         result = NULL;
     355            0 :         U8_LOG_ERROR_INT( "index out of bounds (>=(*this_).relationship_count)", index );
     356              :     }
     357              : 
     358            5 :     return result;
     359              : }
     360              : 
     361          449 : static inline const data_relationship_t *data_visible_set_get_relationship_by_id_const ( const data_visible_set_t *this_, data_row_t row_id )
     362              : {
     363          449 :     assert( (*this_).relationship_count <= DATA_VISIBLE_SET_MAX_RELATIONSHIPS );
     364          449 :     const data_relationship_t *result = NULL;
     365              : 
     366        74679 :     for ( int index = 0; index < (*this_).relationship_count; index ++ )
     367              :     {
     368              :         const data_relationship_t *probe;
     369        74679 :         probe = &((*this_).relationships[index]);
     370        74679 :         if ( row_id == data_relationship_get_row_id( probe ) )
     371              :         {
     372          449 :             result = probe;
     373          449 :             break;
     374              :         }
     375              :     }
     376              : 
     377          449 :     return result;
     378              : }
     379              : 
     380            1 : static inline data_relationship_t *data_visible_set_get_relationship_by_id_ptr ( data_visible_set_t *this_, data_row_t row_id )
     381              : {
     382            1 :     assert( (*this_).relationship_count <= DATA_VISIBLE_SET_MAX_RELATIONSHIPS );
     383            1 :     data_relationship_t *result = NULL;
     384              : 
     385            2 :     for ( int index = 0; index < (*this_).relationship_count; index ++ )
     386              :     {
     387              :         data_relationship_t *probe;
     388            2 :         probe = &((*this_).relationships[index]);
     389            2 :         if ( row_id == data_relationship_get_row_id( probe ) )
     390              :         {
     391            1 :             result = probe;
     392            1 :             break;
     393              :         }
     394              :     }
     395              : 
     396            1 :     return result;
     397              : }
     398              : 
     399            4 : static inline bool data_visible_set_is_ancestor_by_index ( const data_visible_set_t *this_, uint32_t ancestor_index, uint32_t descendant_index )
     400              : {
     401            4 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     402            4 :     assert( ancestor_index < (*this_).visible_classifier_count );
     403            4 :     assert( descendant_index < (*this_).visible_classifier_count );
     404              : 
     405            4 :     return (*this_).containment_cache[ancestor_index][descendant_index];
     406              : }
     407              : 
     408            1 : static inline uint32_t data_visible_set_count_ancestors_of_index ( const data_visible_set_t *this_, uint32_t classifier_index )
     409              : {
     410            1 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     411            1 :     assert( classifier_index < (*this_).visible_classifier_count );
     412              : 
     413            1 :     uint32_t result = 0;
     414              : 
     415            3 :     for ( uint32_t ancestor_index = 0; ancestor_index < (*this_).visible_classifier_count; ancestor_index ++ )
     416              :     {
     417            2 :         if ( (*this_).containment_cache[ancestor_index][classifier_index] )
     418              :         {
     419            1 :             result ++;
     420              :         }
     421              :     }
     422              : 
     423            1 :     return result;
     424              : }
     425              : 
     426            1 : static inline uint32_t data_visible_set_count_descendants_of_index ( const data_visible_set_t *this_, uint32_t classifier_index )
     427              : {
     428            1 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     429            1 :     assert( classifier_index < (*this_).visible_classifier_count );
     430              : 
     431            1 :     uint32_t result = 0;
     432              : 
     433            3 :     for ( uint32_t descendant_index = 0; descendant_index < (*this_).visible_classifier_count; descendant_index ++ )
     434              :     {
     435            2 :         if ( (*this_).containment_cache[classifier_index][descendant_index] )
     436              :         {
     437            1 :             result ++;
     438              :         }
     439              :     }
     440              : 
     441            1 :     return result;
     442              : }
     443              : 
     444          385 : static inline u8_error_t data_visible_set_append_relationship( data_visible_set_t *this_, const data_relationship_t *new_relationship )
     445              : {
     446          385 :     assert( (*this_).relationship_count <= DATA_VISIBLE_SET_MAX_RELATIONSHIPS );
     447          385 :     assert( NULL != new_relationship );
     448          385 :     u8_error_t result = U8_ERROR_NONE;
     449              :     
     450          385 :     const uint32_t new_index = (*this_).relationship_count;
     451          385 :     if ( new_index < DATA_VISIBLE_SET_MAX_RELATIONSHIPS )
     452              :     {
     453          384 :         data_relationship_copy( &((*this_).relationships[new_index]), new_relationship );
     454          384 :         (*this_).relationship_count ++;
     455              :     }
     456              :     else
     457              :     {
     458            1 :         result = U8_ERROR_ARRAY_BUFFER_EXCEEDED;
     459              :     }
     460              :     
     461          385 :     return result;
     462              : }
     463              : 
     464              : /* ================================ misc ================================ */
     465              : 
     466           30 : static inline bool data_visible_set_is_valid ( const data_visible_set_t *this_ )
     467              : {
     468           30 :     return data_diagram_is_valid( &((*this_).diagram) );
     469              : }
     470              : 
     471            1 : static inline void data_visible_set_invalidate ( data_visible_set_t *this_ )
     472              : {
     473            1 :     data_visible_set_reinit( this_ );
     474            1 : }
     475              : 
     476           16 : static inline void data_visible_set_private_destroy_visible_classifiers( data_visible_set_t *this_ )
     477              : {
     478           16 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     479              : 
     480          201 :     for ( int index = 0; index < (*this_).visible_classifier_count; index ++ )
     481              :     {
     482          185 :         data_visible_classifier_destroy ( &((*this_).visible_classifiers[index]) );
     483              :     }
     484              : 
     485           16 :     (*this_).visible_classifier_count = 0;
     486           16 : }
     487              : 
     488           16 : static inline void data_visible_set_private_destroy_features( data_visible_set_t *this_ )
     489              : {
     490           16 :     assert( (*this_).feature_count <= DATA_VISIBLE_SET_MAX_FEATURES );
     491              : 
     492          277 :     for ( int index = 0; index < (*this_).feature_count; index ++ )
     493              :     {
     494          261 :         data_feature_destroy ( &((*this_).features[index]) );
     495              :     }
     496              : 
     497           16 :     (*this_).feature_count = 0;
     498           16 : }
     499              : 
     500           16 : static inline void data_visible_set_private_destroy_relationships( data_visible_set_t *this_ )
     501              : {
     502           16 :     assert( (*this_).relationship_count <= DATA_VISIBLE_SET_MAX_RELATIONSHIPS );
     503              : 
     504          407 :     for ( int index = 0; index < (*this_).relationship_count; index ++ )
     505              :     {
     506          391 :         data_relationship_destroy ( &((*this_).relationships[index]) );
     507              :     }
     508              : 
     509           16 :     (*this_).relationship_count = 0;
     510           16 : }
     511              : 
     512              : 
     513              : /*
     514              : Copyright 2016-2025 Andreas Warnke
     515              : 
     516              : Licensed under the Apache License, Version 2.0 (the "License");
     517              : you may not use this file except in compliance with the License.
     518              : You may obtain a copy of the License at
     519              : 
     520              :     http://www.apache.org/licenses/LICENSE-2.0
     521              : 
     522              : Unless required by applicable law or agreed to in writing, software
     523              : distributed under the License is distributed on an "AS IS" BASIS,
     524              : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     525              : See the License for the specific language governing permissions and
     526              : limitations under the License.
     527              : */
        

Generated by: LCOV version 2.0-1