LCOV - code coverage report
Current view: top level - data/include/entity - data_classifier.inl (source / functions) Hit Total Coverage
Test: crystal-facet-uml_v1.62.0_covts Lines: 182 182 100.0 %
Date: 2024-12-21 18:34:41 Functions: 31 31 100.0 %

          Line data    Source code
       1             : /* File: data_classifier.inl; Copyright and License: see below */
       2             : 
       3             : #include "entity/data_id.h"
       4             : #include "u8/u8_trace.h"
       5             : #include "u8/u8_log.h"
       6             : #include <assert.h>
       7             : 
       8        1115 : static inline void data_classifier_init_empty ( data_classifier_t *this_ )
       9             : {
      10        1115 :     (*this_).id = DATA_ROW_VOID;
      11        1115 :     (*this_).main_type = DATA_CLASSIFIER_TYPE_BLOCK;
      12             : 
      13        1115 :     (*this_).stereotype = utf8stringbuf_init( sizeof((*this_).private_stereotype_buffer), (*this_).private_stereotype_buffer );
      14        1115 :     utf8stringbuf_clear( (*this_).stereotype );
      15        1115 :     (*this_).name = utf8stringbuf_init( sizeof((*this_).private_name_buffer), (*this_).private_name_buffer );
      16        1115 :     utf8stringbuf_clear( (*this_).name );
      17        1115 :     (*this_).description = utf8stringbuf_init( sizeof((*this_).private_description_buffer), (*this_).private_description_buffer );
      18        1115 :     utf8stringbuf_clear( (*this_).description );
      19             : 
      20        1115 :     (*this_).x_order = 0;
      21        1115 :     (*this_).y_order = 0;
      22        1115 :     (*this_).list_order = 0;
      23        1115 :     data_uuid_init_new( &((*this_).uuid) );
      24        1115 : }
      25             : 
      26           1 : static inline void data_classifier_reinit_empty ( data_classifier_t *this_ )
      27             : {
      28             :     /* data_classifier_destroy( this_ );  -- not necessary */
      29           1 :     data_classifier_init_empty( this_ );
      30           1 : }
      31             : 
      32           7 : static inline u8_error_t data_classifier_init_new ( data_classifier_t *this_,
      33             :                                                     data_classifier_type_t main_type,
      34             :                                                     const char* stereotype,
      35             :                                                     const char* name,
      36             :                                                     const char* description,
      37             :                                                     int32_t x_order,
      38             :                                                     int32_t y_order,
      39             :                                                     int32_t list_order )
      40             : {
      41           7 :     assert( NULL != stereotype );
      42           7 :     assert( NULL != name );
      43           7 :     assert( NULL != description );
      44             :     utf8error_t strerr;
      45           7 :     u8_error_t result = U8_ERROR_NONE;
      46             : 
      47           7 :     (*this_).id = DATA_ROW_VOID;
      48           7 :     (*this_).main_type = main_type;
      49             : 
      50           7 :     (*this_).stereotype = utf8stringbuf_init( sizeof((*this_).private_stereotype_buffer), (*this_).private_stereotype_buffer );
      51           7 :     strerr = utf8stringbuf_copy_str( (*this_).stereotype, stereotype );
      52           7 :     if ( strerr != UTF8ERROR_SUCCESS )
      53             :     {
      54           1 :         U8_LOG_ERROR_INT( "utf8stringbuf_copy_str() failed:", strerr );
      55           1 :         result |= U8_ERROR_STRING_BUFFER_EXCEEDED;
      56             :     }
      57             : 
      58           7 :     (*this_).name = utf8stringbuf_init( sizeof((*this_).private_name_buffer), (*this_).private_name_buffer );
      59           7 :     strerr = utf8stringbuf_copy_str( (*this_).name, name );
      60           7 :     if ( strerr != UTF8ERROR_SUCCESS )
      61             :     {
      62           1 :         U8_LOG_ERROR_HEX( "utf8stringbuf_copy_str() failed:", strerr );
      63           1 :         result |= U8_ERROR_STRING_BUFFER_EXCEEDED;
      64             :     }
      65             : 
      66           7 :     (*this_).description = utf8stringbuf_init( sizeof((*this_).private_description_buffer), (*this_).private_description_buffer );
      67           7 :     strerr = utf8stringbuf_copy_str( (*this_).description, description );
      68           7 :     if ( strerr != UTF8ERROR_SUCCESS )
      69             :     {
      70           1 :         U8_LOG_ERROR_HEX( "utf8stringbuf_copy_str() failed:", strerr );
      71           1 :         result |= U8_ERROR_STRING_BUFFER_EXCEEDED;
      72             :     }
      73             : 
      74           7 :     (*this_).x_order = x_order;
      75           7 :     (*this_).y_order = y_order;
      76           7 :     (*this_).list_order = list_order;
      77           7 :     data_uuid_init_new( &((*this_).uuid) );
      78             : 
      79           7 :     return result;
      80             : }
      81             : 
      82        1315 : static inline u8_error_t data_classifier_init ( data_classifier_t *this_,
      83             :                                                 data_row_t id,
      84             :                                                 data_classifier_type_t main_type,
      85             :                                                 const char* stereotype,
      86             :                                                 const char* name,
      87             :                                                 const char* description,
      88             :                                                 int32_t x_order,
      89             :                                                 int32_t y_order,
      90             :                                                 int32_t list_order,
      91             :                                                 const char* uuid )
      92             : {
      93        1315 :     assert( NULL != stereotype );
      94        1315 :     assert( NULL != name );
      95        1315 :     assert( NULL != description );
      96        1315 :     assert( NULL != uuid );
      97             :     utf8error_t strerr;
      98        1315 :     u8_error_t result = U8_ERROR_NONE;
      99             : 
     100        1315 :     (*this_).id = id;
     101        1315 :     (*this_).main_type = main_type;
     102             : 
     103        1315 :     (*this_).stereotype = utf8stringbuf_init( sizeof((*this_).private_stereotype_buffer), (*this_).private_stereotype_buffer );
     104        1315 :     strerr = utf8stringbuf_copy_str( (*this_).stereotype, stereotype );
     105        1315 :     if ( strerr != UTF8ERROR_SUCCESS )
     106             :     {
     107           1 :         U8_LOG_ERROR_HEX( "utf8stringbuf_copy_str() failed:", strerr );
     108           1 :         result |= U8_ERROR_STRING_BUFFER_EXCEEDED;
     109             :     }
     110             : 
     111        1315 :     (*this_).name = utf8stringbuf_init( sizeof((*this_).private_name_buffer), (*this_).private_name_buffer );
     112        1315 :     strerr = utf8stringbuf_copy_str( (*this_).name, name );
     113        1315 :     if ( strerr != UTF8ERROR_SUCCESS )
     114             :     {
     115           1 :         U8_LOG_ERROR_HEX( "utf8stringbuf_copy_str() failed:", strerr );
     116           1 :         result |= U8_ERROR_STRING_BUFFER_EXCEEDED;
     117             :     }
     118             : 
     119        1315 :     (*this_).description = utf8stringbuf_init( sizeof((*this_).private_description_buffer), (*this_).private_description_buffer );
     120        1315 :     strerr = utf8stringbuf_copy_str( (*this_).description, description );
     121        1315 :     if ( strerr != UTF8ERROR_SUCCESS )
     122             :     {
     123           1 :         U8_LOG_ERROR_HEX( "utf8stringbuf_copy_str() failed:", strerr );
     124           1 :         result |= U8_ERROR_STRING_BUFFER_EXCEEDED;
     125             :     }
     126             : 
     127        1315 :     (*this_).x_order = x_order;
     128        1315 :     (*this_).y_order = y_order;
     129        1315 :     (*this_).list_order = list_order;
     130        1315 :     result |= data_uuid_init( &((*this_).uuid), uuid );
     131             : 
     132        1315 :     return result;
     133             : }
     134             : 
     135         196 : static inline u8_error_t data_classifier_reinit ( data_classifier_t *this_,
     136             :                                                   data_row_t id,
     137             :                                                   data_classifier_type_t main_type,
     138             :                                                   const char* stereotype,
     139             :                                                   const char* name,
     140             :                                                   const char* description,
     141             :                                                   int32_t x_order,
     142             :                                                   int32_t y_order,
     143             :                                                   int32_t list_order,
     144             :                                                   const char* uuid )
     145             : {
     146         196 :     return data_classifier_init( this_, id, main_type, stereotype, name, description, x_order, y_order, list_order, uuid );
     147             : }
     148             : 
     149         173 : static inline void data_classifier_copy ( data_classifier_t *this_, const data_classifier_t *original )
     150             : {
     151         173 :     assert( NULL != original );
     152             : 
     153         173 :     (*this_) = (*original);
     154             :     /* repair the overwritten pointers */
     155         173 :     (*this_).stereotype = utf8stringbuf_init( sizeof((*this_).private_stereotype_buffer), (*this_).private_stereotype_buffer );
     156         173 :     (*this_).name = utf8stringbuf_init( sizeof((*this_).private_name_buffer), (*this_).private_name_buffer );
     157         173 :     (*this_).description = utf8stringbuf_init( sizeof((*this_).private_description_buffer), (*this_).private_description_buffer );
     158         173 :     data_uuid_copy( &((*this_).uuid), &((*original).uuid) );
     159         173 : }
     160             : 
     161          57 : static inline void data_classifier_replace ( data_classifier_t *this_, const data_classifier_t *that )
     162             : {
     163          57 :     assert( NULL != that );
     164             : 
     165          57 :     (*this_) = (*that);
     166             :     /* repair the overwritten pointers */
     167          57 :     (*this_).stereotype = utf8stringbuf_init( sizeof((*this_).private_stereotype_buffer), (*this_).private_stereotype_buffer );
     168          57 :     (*this_).name = utf8stringbuf_init( sizeof((*this_).private_name_buffer), (*this_).private_name_buffer );
     169          57 :     (*this_).description = utf8stringbuf_init( sizeof((*this_).private_description_buffer), (*this_).private_description_buffer );
     170          57 :     data_uuid_replace( &((*this_).uuid), &((*that).uuid) );
     171          57 : }
     172             : 
     173         709 : static inline void data_classifier_destroy ( data_classifier_t *this_ )
     174             : {
     175         709 :     (*this_).id = DATA_ROW_VOID;
     176         709 :     data_uuid_destroy( &((*this_).uuid) );
     177         709 : }
     178             : 
     179         312 : static inline void data_classifier_trace ( const data_classifier_t *this_ )
     180             : {
     181         312 :     U8_TRACE_INFO( "data_classifier_t" );
     182         312 :     U8_TRACE_INFO_INT( "- id:", (*this_).id );
     183         312 :     U8_TRACE_INFO_INT( "- main_type:", (*this_).main_type );
     184         312 :     U8_TRACE_INFO_STR( "- stereotype:", utf8stringbuf_get_string((*this_).stereotype) );
     185         312 :     U8_TRACE_INFO_STR( "- name:", utf8stringbuf_get_string((*this_).name) );
     186         312 :     U8_TRACE_INFO_STR( "- description:", utf8stringbuf_get_string((*this_).description) );
     187         312 :     U8_TRACE_INFO_INT( "- x_order:", (*this_).x_order );
     188         312 :     U8_TRACE_INFO_INT( "- y_order:", (*this_).y_order );
     189         312 :     U8_TRACE_INFO_INT( "- list_order:", (*this_).list_order );
     190         312 :     U8_TRACE_INFO_STR( "- uuid:", data_uuid_get_string( &((*this_).uuid) ) );
     191         312 : }
     192             : 
     193      247406 : static inline data_row_t data_classifier_get_row_id ( const data_classifier_t *this_ )
     194             : {
     195      247406 :     return (*this_).id;
     196             : }
     197             : 
     198          57 : static inline void data_classifier_set_row_id ( data_classifier_t *this_, data_row_t id )
     199             : {
     200          57 :     (*this_).id = id;
     201          57 : }
     202             : 
     203           1 : static inline data_id_t data_classifier_get_data_id ( const data_classifier_t *this_ )
     204             : {
     205             :     data_id_t result;
     206           1 :     data_id_init ( &result, DATA_TABLE_CLASSIFIER, (*this_).id );
     207           1 :     return result;
     208             : }
     209             : 
     210       34625 : static inline data_classifier_type_t data_classifier_get_main_type ( const data_classifier_t *this_ )
     211             : {
     212       34625 :     return (*this_).main_type;
     213             : }
     214             : 
     215         112 : static inline void data_classifier_set_main_type ( data_classifier_t *this_, data_classifier_type_t main_type )
     216             : {
     217         112 :     (*this_).main_type = main_type;
     218         112 : }
     219             : 
     220         826 : static inline const char *data_classifier_get_stereotype_const ( const data_classifier_t *this_ )
     221             : {
     222         826 :     return utf8stringbuf_get_string( (*this_).stereotype );
     223             : }
     224             : 
     225         311 : static inline bool data_classifier_has_stereotype ( const data_classifier_t *this_ )
     226             : {
     227         311 :     return ( ! utf8stringbuf_equals_str( (*this_).stereotype, "" ) );
     228             : }
     229             : 
     230          18 : static inline u8_error_t data_classifier_set_stereotype ( data_classifier_t *this_, const char *stereotype )
     231             : {
     232          18 :     assert( NULL != stereotype );
     233             : 
     234          18 :     u8_error_t result = U8_ERROR_NONE;
     235             :     utf8error_t strerr;
     236          18 :     strerr = utf8stringbuf_copy_str( (*this_).stereotype, stereotype );
     237          18 :     if ( strerr != UTF8ERROR_SUCCESS )
     238             :     {
     239           1 :         U8_LOG_ERROR_HEX( "utf8stringbuf_copy_str() failed:", strerr );
     240           1 :         result = U8_ERROR_STRING_BUFFER_EXCEEDED;
     241             :     }
     242          18 :     return result;
     243             : }
     244             : 
     245        2219 : static inline const char *data_classifier_get_name_const ( const data_classifier_t *this_ )
     246             : {
     247        2219 :     return utf8stringbuf_get_string( (*this_).name );
     248             : }
     249             : 
     250          23 : static inline u8_error_t data_classifier_set_name ( data_classifier_t *this_, const char *name )
     251             : {
     252          23 :     assert( NULL != name );
     253             : 
     254          23 :     u8_error_t result = U8_ERROR_NONE;
     255             :     utf8error_t strerr;
     256          23 :     strerr = utf8stringbuf_copy_str( (*this_).name, name );
     257          23 :     if ( strerr != UTF8ERROR_SUCCESS )
     258             :     {
     259           1 :         U8_LOG_ERROR_HEX( "utf8stringbuf_copy_str() failed:", strerr );
     260           1 :         result = U8_ERROR_STRING_BUFFER_EXCEEDED;
     261             :     }
     262          23 :     return result;
     263             : }
     264             : 
     265         269 : static inline const char *data_classifier_get_description_const ( const data_classifier_t *this_ )
     266             : {
     267         269 :     return utf8stringbuf_get_string( (*this_).description );
     268             : }
     269             : 
     270          17 : static inline u8_error_t data_classifier_set_description ( data_classifier_t *this_, const char *description )
     271             : {
     272          17 :     assert( NULL != description );
     273             : 
     274          17 :     u8_error_t result = U8_ERROR_NONE;
     275             :     utf8error_t strerr;
     276          17 :     strerr = utf8stringbuf_copy_str( (*this_).description, description );
     277          17 :     if ( strerr != UTF8ERROR_SUCCESS )
     278             :     {
     279           1 :         U8_LOG_ERROR_HEX( "utf8stringbuf_copy_str() failed:", strerr );
     280           1 :         result = U8_ERROR_STRING_BUFFER_EXCEEDED;
     281             :     }
     282          17 :     return result;
     283             : }
     284             : 
     285           2 : static inline u8_error_t data_classifier_append_description ( data_classifier_t *this_, const char *description )
     286             : {
     287           2 :     assert( NULL != description );
     288             : 
     289           2 :     u8_error_t result = U8_ERROR_NONE;
     290             :     utf8error_t strerr;
     291           2 :     strerr = utf8stringbuf_append_str( (*this_).description, description );
     292           2 :     if ( strerr != UTF8ERROR_SUCCESS )
     293             :     {
     294           1 :         U8_LOG_ERROR_HEX( "utf8stringbuf_append_str() failed:", strerr );
     295           1 :         result = U8_ERROR_STRING_BUFFER_EXCEEDED;
     296             :     }
     297           2 :     return result;
     298             : }
     299             : 
     300         258 : static inline int32_t data_classifier_get_x_order ( const data_classifier_t *this_ )
     301             : {
     302         258 :     return (*this_).x_order;
     303             : }
     304             : 
     305          16 : static inline void data_classifier_set_x_order ( data_classifier_t *this_, int32_t x_order )
     306             : {
     307          16 :     (*this_).x_order = x_order;
     308          16 : }
     309             : 
     310         258 : static inline int32_t data_classifier_get_y_order ( const data_classifier_t *this_ )
     311             : {
     312         258 :     return (*this_).y_order;
     313             : }
     314             : 
     315          16 : static inline void data_classifier_set_y_order ( data_classifier_t *this_, int32_t y_order )
     316             : {
     317          16 :     (*this_).y_order = y_order;
     318          16 : }
     319             : 
     320         257 : static inline int32_t data_classifier_get_list_order ( const data_classifier_t *this_ )
     321             : {
     322         257 :     return (*this_).list_order;
     323             : }
     324             : 
     325          15 : static inline void data_classifier_set_list_order ( data_classifier_t *this_, int32_t list_order )
     326             : {
     327          15 :     (*this_).list_order = list_order;
     328          15 : }
     329             : 
     330         300 : static inline const char *data_classifier_get_uuid_const ( const data_classifier_t *this_ )
     331             : {
     332         300 :     return data_uuid_get_string( &((*this_).uuid) );
     333             : }
     334             : 
     335          14 : static inline u8_error_t data_classifier_set_uuid ( data_classifier_t *this_, const char *uuid )
     336             : {
     337          14 :     assert( NULL != uuid );
     338             : 
     339          14 :     const u8_error_t result = data_uuid_reinit( &((*this_).uuid), uuid );
     340             : 
     341          14 :     return result;
     342             : }
     343             : 
     344      100030 : static inline bool data_classifier_is_valid ( const data_classifier_t *this_ )
     345             : {
     346      100030 :     return ( DATA_ROW_VOID != (*this_).id );
     347             : }
     348             : 
     349             : 
     350             : /*
     351             : Copyright 2016-2024 Andreas Warnke
     352             : 
     353             : Licensed under the Apache License, Version 2.0 (the "License");
     354             : you may not use this file except in compliance with the License.
     355             : You may obtain a copy of the License at
     356             : 
     357             :     http://www.apache.org/licenses/LICENSE-2.0
     358             : 
     359             : Unless required by applicable law or agreed to in writing, software
     360             : distributed under the License is distributed on an "AS IS" BASIS,
     361             : WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     362             : See the License for the specific language governing permissions and
     363             : limitations under the License.
     364             : */

Generated by: LCOV version 1.16