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        1412 : static inline const data_diagram_t *data_visible_set_get_diagram_const ( const data_visible_set_t *this_ )
       9             : {
      10        1412 :     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          38 : static inline uint32_t data_visible_set_get_visible_classifier_count ( const data_visible_set_t *this_ )
      28             : {
      29          38 :     return (*this_).visible_classifier_count;
      30             : }
      31             : 
      32        2253 : 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        2253 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
      35             : 
      36             :     const data_visible_classifier_t *result;
      37        2253 :     if ( index < (*this_).visible_classifier_count )
      38             :     {
      39        2253 :         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        2253 :     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_id_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_id_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        2486 : static inline const data_classifier_t *data_visible_set_get_classifier_by_id_const ( const data_visible_set_t *this_, data_row_id_t row_id )
     117             : {
     118        2486 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     119        2486 :     const data_classifier_t *result = NULL;
     120             : 
     121      128946 :     for ( int index = 0; index < (*this_).visible_classifier_count; index ++ )
     122             :     {
     123             :         const data_visible_classifier_t *visible_classifier;
     124      128911 :         visible_classifier = &((*this_).visible_classifiers[index]);
     125      128911 :         assert ( data_visible_classifier_is_valid( visible_classifier ) );
     126             : 
     127             :         const data_classifier_t *probe;
     128      128911 :         probe = data_visible_classifier_get_classifier_const( visible_classifier );
     129      128911 :         if ( row_id == data_classifier_get_row_id( probe ) )
     130             :         {
     131        2451 :             result = probe;
     132        2451 :             break;
     133             :         }
     134             :     }
     135             : 
     136        2486 :     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_id_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        2052 : static inline int32_t data_visible_set_get_classifier_index ( const data_visible_set_t *this_, data_row_id_t row_id )
     163             : {
     164        2052 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     165        2052 :     int32_t result = -1;
     166             : 
     167        3078 :     for ( int index = 0; index < (*this_).visible_classifier_count; index ++ )
     168             :     {
     169             :         const data_classifier_t *probe;
     170        3078 :         probe = data_visible_classifier_get_classifier_const( &((*this_).visible_classifiers[index]) );
     171        3078 :         if ( row_id == data_classifier_get_row_id( probe ) )
     172             :         {
     173        2052 :             result = index;
     174        2052 :             break;
     175             :         }
     176             :     }
     177             : 
     178        2052 :     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          13 : static inline uint32_t data_visible_set_get_feature_count ( const data_visible_set_t *this_ )
     214             : {
     215          13 :     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        2460 : static inline const data_feature_t *data_visible_set_get_feature_by_id_const ( const data_visible_set_t *this_, data_row_id_t row_id )
     255             : {
     256        2460 :     assert( (*this_).feature_count <= DATA_VISIBLE_SET_MAX_FEATURES );
     257        2460 :     const data_feature_t *result = NULL;
     258             : 
     259      567216 :     for ( int index = 0; index < (*this_).feature_count; index ++ )
     260             :     {
     261             :         const data_feature_t *probe;
     262      565105 :         probe = &((*this_).features[index]);
     263      565105 :         if ( row_id == data_feature_get_row_id( probe ) )
     264             :         {
     265         349 :             result = probe;
     266         349 :             break;
     267             :         }
     268             :     }
     269             : 
     270        2460 :     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_id_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          13 : static inline uint32_t data_visible_set_get_relationship_count ( const data_visible_set_t *this_ )
     321             : {
     322          13 :     return (*this_).relationship_count;
     323             : }
     324             : 
     325        2085 : static inline const data_relationship_t *data_visible_set_get_relationship_const ( const data_visible_set_t *this_, uint32_t index )
     326             : {
     327        2085 :     assert( (*this_).relationship_count <= DATA_VISIBLE_SET_MAX_RELATIONSHIPS );
     328             : 
     329             :     const data_relationship_t *result;
     330        2085 :     if ( index < (*this_).relationship_count )
     331             :     {
     332        2085 :         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        2085 :     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        1085 : static inline const data_relationship_t *data_visible_set_get_relationship_by_id_const ( const data_visible_set_t *this_, data_row_id_t row_id )
     362             : {
     363        1085 :     assert( (*this_).relationship_count <= DATA_VISIBLE_SET_MAX_RELATIONSHIPS );
     364        1085 :     const data_relationship_t *result = NULL;
     365             : 
     366      525549 :     for ( int index = 0; index < (*this_).relationship_count; index ++ )
     367             :     {
     368             :         const data_relationship_t *probe;
     369      525549 :         probe = &((*this_).relationships[index]);
     370      525549 :         if ( row_id == data_relationship_get_row_id( probe ) )
     371             :         {
     372        1085 :             result = probe;
     373        1085 :             break;
     374             :         }
     375             :     }
     376             : 
     377        1085 :     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_id_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        1025 : static inline u8_error_t data_visible_set_append_relationship( data_visible_set_t *this_, const data_relationship_t *new_relationship )
     445             : {
     446        1025 :     assert( (*this_).relationship_count <= DATA_VISIBLE_SET_MAX_RELATIONSHIPS );
     447        1025 :     assert( NULL != new_relationship );
     448        1025 :     u8_error_t result = U8_ERROR_NONE;
     449             :     
     450        1025 :     const uint32_t new_index = (*this_).relationship_count;
     451        1025 :     if ( new_index < DATA_VISIBLE_SET_MAX_RELATIONSHIPS )
     452             :     {
     453        1024 :         data_relationship_copy( &((*this_).relationships[new_index]), new_relationship );
     454        1024 :         (*this_).relationship_count ++;
     455             :     }
     456             :     else
     457             :     {
     458           1 :         result = U8_ERROR_ARRAY_BUFFER_EXCEEDED;
     459             :     }
     460             :     
     461        1025 :     return result;
     462             : }
     463             : 
     464             : /* ================================ misc ================================ */
     465             : 
     466          29 : static inline bool data_visible_set_is_valid ( const data_visible_set_t *this_ )
     467             : {
     468          29 :     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          13 : static inline void data_visible_set_private_destroy_visible_classifiers( data_visible_set_t *this_ )
     477             : {
     478          13 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     479             : 
     480         172 :     for ( int index = 0; index < (*this_).visible_classifier_count; index ++ )
     481             :     {
     482         159 :         data_visible_classifier_destroy ( &((*this_).visible_classifiers[index]) );
     483             :     }
     484             : 
     485          13 :     (*this_).visible_classifier_count = 0;
     486          13 : }
     487             : 
     488          13 : static inline void data_visible_set_private_destroy_features( data_visible_set_t *this_ )
     489             : {
     490          13 :     assert( (*this_).feature_count <= DATA_VISIBLE_SET_MAX_FEATURES );
     491             : 
     492         272 :     for ( int index = 0; index < (*this_).feature_count; index ++ )
     493             :     {
     494         259 :         data_feature_destroy ( &((*this_).features[index]) );
     495             :     }
     496             : 
     497          13 :     (*this_).feature_count = 0;
     498          13 : }
     499             : 
     500          13 : static inline void data_visible_set_private_destroy_relationships( data_visible_set_t *this_ )
     501             : {
     502          13 :     assert( (*this_).relationship_count <= DATA_VISIBLE_SET_MAX_RELATIONSHIPS );
     503             : 
     504        1040 :     for ( int index = 0; index < (*this_).relationship_count; index ++ )
     505             :     {
     506        1027 :         data_relationship_destroy ( &((*this_).relationships[index]) );
     507             :     }
     508             : 
     509          13 :     (*this_).relationship_count = 0;
     510          13 : }
     511             : 
     512             : 
     513             : /*
     514             : Copyright 2016-2024 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             : */