Line data    Source code

       1             : /* File: data_visible_set.c; Copyright and License: see below */
       2             : 
       3             : #include "set/data_visible_set.h"
       4             : #include "data_rules.h"
       5             : #include "u8/u8_trace.h"
       6             : #include <stdio.h>
       7             : #include <stdlib.h>
       8             : #include <assert.h>
       9             : 
      10          17 : void data_visible_set_init( data_visible_set_t *this_ )
      11             : {
      12          17 :     U8_TRACE_BEGIN();
      13          17 :     U8_TRACE_INFO_INT( "sizeof(data_visible_set_t):", sizeof(data_visible_set_t) );
      14             : 
      15          17 :     data_diagram_init_empty( &((*this_).diagram) );
      16          17 :     (*this_).visible_classifier_count = 0;
      17          17 :     (*this_).feature_count = 0;
      18          17 :     (*this_).relationship_count = 0;
      19             : 
      20          17 :     U8_TRACE_END();
      21          17 : }
      22             : 
      23           1 : void data_visible_set_reinit( data_visible_set_t *this_ )
      24             : {
      25           1 :     U8_TRACE_BEGIN();
      26             : 
      27           1 :     data_diagram_reinit_empty( &((*this_).diagram) );
      28           1 :     data_visible_set_private_destroy_visible_classifiers( this_ );
      29           1 :     data_visible_set_private_destroy_features( this_ );
      30           1 :     data_visible_set_private_destroy_relationships( this_ );
      31             : 
      32           1 :     U8_TRACE_END();
      33             : 
      34           1 : }
      35             : 
      36           7 : void data_visible_set_destroy( data_visible_set_t *this_ )
      37             : {
      38           7 :     U8_TRACE_BEGIN();
      39             : 
      40           7 :     data_diagram_destroy( &((*this_).diagram) );
      41           7 :     data_visible_set_private_destroy_visible_classifiers( this_ );
      42           7 :     data_visible_set_private_destroy_features( this_ );
      43           7 :     data_visible_set_private_destroy_relationships( this_ );
      44             : 
      45           7 :     U8_TRACE_END();
      46           7 : }
      47             : 
      48           8 : u8_error_t data_visible_set_load( data_visible_set_t *this_, data_row_t diagram_id, data_database_reader_t *db_reader )
      49             : {
      50           8 :     U8_TRACE_BEGIN();
      51           8 :     assert( NULL != db_reader );
      52           8 :     u8_error_t result = U8_ERROR_NONE;
      53             : 
      54           8 :     if ( DATA_ROW_VOID == diagram_id )
      55             :     {
      56             :         /* re-init */
      57           1 :         data_diagram_reinit_empty( &((*this_).diagram) );
      58             : 
      59           1 :         data_visible_set_private_destroy_visible_classifiers( this_ );
      60           1 :         data_visible_set_private_destroy_features( this_ );
      61           1 :         data_visible_set_private_destroy_relationships( this_ );
      62             :     }
      63             :     else
      64             :     {
      65           7 :         data_diagram_destroy( &((*this_).diagram) );
      66           7 :         data_visible_set_private_destroy_visible_classifiers( this_ );
      67           7 :         data_visible_set_private_destroy_features( this_ );
      68           7 :         data_visible_set_private_destroy_relationships( this_ );
      69             : 
      70             :         data_rules_t rules;
      71           7 :         data_rules_init( &rules );
      72             : 
      73             :         /* load diagram */
      74             :         {
      75             :             const u8_error_t diag_err
      76           7 :                 = data_database_reader_get_diagram_by_id ( db_reader, diagram_id, &((*this_).diagram) );
      77           7 :             if ( u8_error_contains( diag_err, U8_ERROR_STRING_BUFFER_EXCEEDED ) )
      78             :             {
      79           0 :                 U8_LOG_ERROR( "U8_ERROR_STRING_BUFFER_EXCEEDED at loading a diagram" );
      80             :             }
      81           7 :             if ( u8_error_more_than( diag_err, U8_ERROR_STRING_BUFFER_EXCEEDED ) )
      82             :             {
      83             :                 /* error at loading */
      84           1 :                 data_diagram_reinit_empty( &((*this_).diagram) );
      85             :             }
      86           7 :             result |= diag_err;  /* collect error flags */
      87             :         }
      88             : 
      89             :         /* load classifiers */
      90             :         {
      91           7 :             u8_error_t c_err = U8_ERROR_NONE;
      92           7 :             (*this_).visible_classifier_count = 0;
      93             :             data_visible_classifier_iterator_t visible_classifier_iterator;
      94           7 :             c_err |= data_visible_classifier_iterator_init_empty( &visible_classifier_iterator );
      95           7 :             c_err |= data_database_reader_get_visible_classifiers_by_diagram_id( db_reader,
      96             :                                                                                  diagram_id,
      97             :                                                                                  &visible_classifier_iterator
      98             :                                                                                );
      99         193 :             while ( data_visible_classifier_iterator_has_next( &visible_classifier_iterator )
     100         193 :                 && ( ! u8_error_more_than( c_err, U8_ERROR_STRING_BUFFER_EXCEEDED ) ) )
     101             :             {
     102         186 :                 if ( (*this_).visible_classifier_count < DATA_VISIBLE_SET_MAX_CLASSIFIERS )
     103             :                 {
     104         185 :                     data_visible_classifier_t *const current_visible_classifier
     105         185 :                         = &((*this_).visible_classifiers[(*this_).visible_classifier_count]);
     106         185 :                     c_err |= data_visible_classifier_iterator_next( &visible_classifier_iterator,
     107             :                                                                     current_visible_classifier
     108             :                                                                   );
     109         185 :                     if ( ! u8_error_more_than( c_err, U8_ERROR_STRING_BUFFER_EXCEEDED ) )
     110             :                     {
     111         185 :                         (*this_).visible_classifier_count ++;
     112             :                     }
     113             :                 }
     114             :                 else
     115             :                 {
     116           1 :                     c_err |= U8_ERROR_ARRAY_BUFFER_EXCEEDED;
     117           1 :                     U8_LOG_ERROR( "U8_ERROR_ARRAY_BUFFER_EXCEEDED at loading visible classifiers of a diagram" );
     118             :                 }
     119             :             }
     120           7 :             c_err |= data_visible_classifier_iterator_destroy( &visible_classifier_iterator );
     121           7 :             result |= c_err;  /* collect error flags */
     122             :         }
     123             : 
     124             :         /* load features */
     125             :         {
     126           7 :             u8_error_t f_err = U8_ERROR_NONE;
     127           7 :             (*this_).feature_count = 0;
     128             :             data_feature_iterator_t feature_iterator;
     129           7 :             f_err |= data_feature_iterator_init_empty( &feature_iterator );
     130           7 :             f_err |= data_database_reader_get_features_by_diagram_id( db_reader,
     131             :                                                                       diagram_id,
     132             :                                                                       &feature_iterator
     133             :                                                                     );
     134         269 :             while ( data_feature_iterator_has_next( &feature_iterator )
     135         269 :                 && ( ! u8_error_more_than( f_err, U8_ERROR_STRING_BUFFER_EXCEEDED ) ) )
     136             :             {
     137         262 :                 if ( (*this_).feature_count < DATA_VISIBLE_SET_MAX_FEATURES )
     138             :                 {
     139         261 :                     data_feature_t *const current_feature = &((*this_).features[(*this_).feature_count]);
     140         261 :                     f_err |= data_feature_iterator_next( &feature_iterator, current_feature );
     141         261 :                     if ( ! u8_error_more_than( f_err, U8_ERROR_STRING_BUFFER_EXCEEDED ) )
     142             :                     {
     143             :                         /* Ignore lifelines (== is_scenario) that do not belong to current diagram */
     144             :                         /* NOTE: The iteraltor already filters lifelines that do not belong to the current diagram, see DATA_FEATURE_ITERATOR_SELECT_FEATURES_BY_DIAGRAM_ID */
     145             : #if 0
     146             :                         const bool is_scenario =
     147             :                             data_rules_feature_is_scenario_cond( &rules, data_feature_get_main_type( current_feature ) );
     148             :                         bool is_foreign_scenario = is_scenario;
     149             :                         for( uint_fast32_t vc_idx = 0; vc_idx < (*this_).visible_classifier_count; vc_idx ++ )
     150             :                         {
     151             :                             const data_diagramelement_t *const diag_ele
     152             :                                 = data_visible_classifier_get_diagramelement_const( &((*this_).visible_classifiers[vc_idx]) );
     153             :                             const data_row_t focus_id = data_diagramelement_get_focused_feature_row_id( diag_ele );
     154             :                             if ( data_feature_get_row_id( current_feature ) == focus_id )
     155             :                             {
     156             :                                 is_foreign_scenario = false;
     157             :                             }
     158             :                         }
     159             :                         if ( ! is_foreign_scenario ) /* either not a scenario or a scenario that is in scope of the diagram */
     160             :                         {
     161             : #endif
     162         261 :                             (*this_).feature_count++;
     163             : #if 0
     164             :                         }
     165             :                         else
     166             :                         {
     167             :                             U8_TRACE_INFO_INT( "filtered a foreign scenario lifeline:",
     168             :                                                data_feature_get_row_id( current_feature )
     169             :                                              );
     170             :                         }
     171             : #endif
     172             :                     }
     173             :                 }
     174             :                 else
     175             :                 {
     176           1 :                     f_err |= U8_ERROR_ARRAY_BUFFER_EXCEEDED;
     177           1 :                     U8_LOG_ERROR( "U8_ERROR_ARRAY_BUFFER_EXCEEDED at loading features of a diagram" );
     178             :                 }
     179             :             }
     180           7 :             f_err |= data_feature_iterator_destroy( &feature_iterator );
     181           7 :             result |= f_err;  /* collect error flags */
     182             :         }
     183             : 
     184             :         /* load relationships */
     185             :         {
     186           7 :             u8_error_t r_err = U8_ERROR_NONE;
     187           7 :             (*this_).relationship_count = 0;
     188             :             data_relationship_iterator_t rel_iterator;
     189           7 :             r_err |= data_relationship_iterator_init_empty( &rel_iterator );
     190           7 :             r_err |= data_database_reader_get_relationships_by_diagram_id( db_reader,
     191             :                                                                            diagram_id,
     192             :                                                                            &rel_iterator
     193             :                                                                          );
     194         402 :             while ( data_relationship_iterator_has_next( &rel_iterator )
     195         402 :                 && ( ! u8_error_more_than( r_err, U8_ERROR_STRING_BUFFER_EXCEEDED ) ) )
     196             :             {
     197         395 :                 if ( (*this_).relationship_count < DATA_VISIBLE_SET_MAX_RELATIONSHIPS )
     198             :                 {
     199         394 :                     data_relationship_t *const current_relationship = &((*this_).relationships[(*this_).relationship_count]);
     200         394 :                     r_err |= data_relationship_iterator_next( &rel_iterator, current_relationship );
     201         394 :                     if ( ! u8_error_more_than( r_err, U8_ERROR_STRING_BUFFER_EXCEEDED ) )
     202             :                     {
     203             :                         /* Ignore relationships that have not both ends in current diagram - e.g. messages between foreign lifelines */
     204         394 :                         const data_row_t from_feat_row_id = data_relationship_get_from_feature_row_id( current_relationship );
     205         394 :                         const data_row_t to_feat_row_id = data_relationship_get_to_feature_row_id( current_relationship );
     206         394 :                         bool from_known = ( from_feat_row_id == DATA_ROW_VOID );
     207         394 :                         bool to_known = ( to_feat_row_id == DATA_ROW_VOID );
     208       98717 :                         for( uint_fast32_t f_idx = 0; f_idx < (*this_).feature_count; f_idx ++ )
     209             :                         {
     210       98323 :                             const data_feature_t *const probe_feature = &((*this_).features[f_idx]);
     211       98323 :                             const data_row_t probe_feat_id = data_feature_get_row_id( probe_feature );
     212       98323 :                             if ( probe_feat_id == from_feat_row_id )
     213             :                             {
     214           4 :                                 from_known = true;
     215             :                             }
     216       98323 :                             if ( probe_feat_id == to_feat_row_id )
     217             :                             {
     218           3 :                                 to_known = true;
     219             :                             }
     220             :                         }
     221         394 :                         if ( from_known && to_known )  /* check that both relationship ends are in this data_visible_set_t */
     222             :                         {
     223         391 :                             (*this_).relationship_count++;
     224             :                         }
     225             :                         else
     226             :                         {
     227           3 :                             U8_TRACE_INFO_INT( "filtered a foreign scenario message:",
     228             :                                                data_relationship_get_row_id( current_relationship )
     229             :                                              );
     230             :                         }
     231             :                     }
     232             :                 }
     233             :                 else
     234             :                 {
     235           1 :                     r_err |= U8_ERROR_ARRAY_BUFFER_EXCEEDED;
     236           1 :                     U8_LOG_ERROR( "U8_ERROR_ARRAY_BUFFER_EXCEEDED at loading relationships of a diagram" );
     237             :                 }
     238             :             }
     239           7 :             r_err |= data_relationship_iterator_destroy( &rel_iterator );
     240           7 :             result |= r_err;  /* collect error flags */
     241             :         }
     242             : 
     243           7 :         data_rules_destroy( &rules );
     244             :     }
     245             : 
     246             :     /* update the containment cache */
     247           8 :     data_visible_set_update_containment_cache( this_ );
     248             : 
     249           8 :     U8_TRACE_END_ERR(result);
     250           8 :     return result;
     251             : }
     252             : 
     253          18 : void data_visible_set_update_containment_cache ( data_visible_set_t *this_ )
     254             : {
     255          18 :     U8_TRACE_BEGIN();
     256          18 :     assert( (*this_).relationship_count <= DATA_VISIBLE_SET_MAX_RELATIONSHIPS );
     257          18 :     assert( (*this_).visible_classifier_count <= DATA_VISIBLE_SET_MAX_CLASSIFIERS );
     258             : 
     259             :     /* reset the containment array */
     260          18 :     memset( &((*this_).containment_cache), '\0', sizeof( (*this_).containment_cache ) );
     261             : 
     262             :     static const int MAX_SEARCH_PASSES = 4;  /* with 4 passes, we can find ancesters and decendants which are related via 2*4=8 links and more */
     263          18 :     bool new_containments_found = true;
     264             : 
     265          36 :     for ( int pass = 0; ( pass < MAX_SEARCH_PASSES ) && new_containments_found; pass ++ )
     266             :     {
     267          18 :         new_containments_found = false;
     268             : 
     269        2748 :         for ( uint32_t rel_idx = 0; rel_idx < (*this_).relationship_count; rel_idx ++ )
     270             :         {
     271             :             data_relationship_t *the_relationship;
     272        2730 :             the_relationship = &((*this_).relationships[rel_idx]);
     273             : 
     274             :             data_relationship_type_t the_type;
     275        2730 :             the_type = data_relationship_get_main_type ( the_relationship );
     276             : 
     277        2730 :             if ( DATA_RELATIONSHIP_TYPE_UML_CONTAINMENT == the_type )
     278             :             {
     279             :                 data_row_t parent_id;
     280             :                 data_row_t child_id;
     281         385 :                 parent_id = data_relationship_get_from_classifier_row_id ( the_relationship );
     282         385 :                 child_id = data_relationship_get_to_classifier_row_id ( the_relationship );
     283             :                 int32_t parent_index;
     284             :                 int32_t child_index;
     285         385 :                 parent_index = data_visible_set_get_classifier_index ( this_, parent_id );
     286         385 :                 child_index = data_visible_set_get_classifier_index ( this_, child_id );
     287         385 :                 if ( ( parent_index != -1 )&&( child_index != -1 ) )
     288             :                 {
     289         385 :                     assert ( 0 <= parent_index );
     290         385 :                     assert ( parent_index < (*this_).visible_classifier_count );
     291         385 :                     assert ( 0 <= child_index );
     292         385 :                     assert ( child_index < (*this_).visible_classifier_count );
     293             : 
     294             :                     /* add the current relation to the containment_cache */
     295         385 :                     (*this_).containment_cache[parent_index][child_index] = true;
     296             : 
     297             :                     /* all ancestors of parent are ancestors of child */
     298       49539 :                     for ( uint32_t ancestor_index = 0; ancestor_index < (*this_).visible_classifier_count; ancestor_index ++ )
     299             :                     {
     300       49154 :                         if ( (*this_).containment_cache[ancestor_index][parent_index] )
     301             :                         {
     302           0 :                             if ( ! (*this_).containment_cache[ancestor_index][child_index] )
     303             :                             {
     304           0 :                                 new_containments_found = true;
     305           0 :                                 (*this_).containment_cache[ancestor_index][child_index] = true;
     306             :                             }
     307             :                         }
     308             :                     }
     309             : 
     310             :                     /* all descendants of child are descendants of parent */
     311       49539 :                     for ( uint32_t descendant_index = 0; descendant_index < (*this_).visible_classifier_count; descendant_index ++ )
     312             :                     {
     313       49154 :                         if ( (*this_).containment_cache[child_index][descendant_index] )
     314             :                         {
     315           0 :                             if ( ! (*this_).containment_cache[parent_index][descendant_index] )
     316             :                             {
     317           0 :                                 new_containments_found = true;
     318           0 :                                 (*this_).containment_cache[parent_index][descendant_index] = true;
     319             :                             }
     320             :                         }
     321             :                     }
     322             : 
     323             :                 }
     324             :                 /* else relation points outside the set of classifiers visible in current diagram */
     325             :             }
     326             :         }
     327             :     }
     328             : 
     329          18 :     U8_TRACE_END();
     330          18 : }
     331             : 
     332             : 
     333             : /*
     334             : Copyright 2016-2025 Andreas Warnke
     335             : 
     336             : Licensed under the Apache License, Version 2.0 (the "License");
     337             : you may not use this file except in compliance with the License.
     338             : You may obtain a copy of the License at
     339             : 
     340             :     http://www.apache.org/licenses/LICENSE-2.0
     341             : 
     342             : Unless required by applicable law or agreed to in writing, software
     343             : distributed under the License is distributed on an "AS IS" BASIS,
     344             : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     345             : See the License for the specific language governing permissions and
     346             : limitations under the License.
     347             : */