Branch data     Line data    Source code

       1                 :            : #include "TagInfo.hpp"
       2                 :            : #include "moab/Error.hpp"
       3                 :            : #include "moab/ErrorHandler.hpp"
       4                 :            : #include <string.h> /* memcpy */
       5                 :            : #include <stdlib.h> /* realloc & free */
       6                 :            : #include <assert.h>
       7                 :            : 
       8                 :            : namespace moab
       9                 :            : {
      10                 :            : 
      11                 :       3037 : TagInfo::TagInfo( const char* name, int size, DataType type, const void* default_value, int default_value_size )
      12                 :            :     : mDefaultValue( NULL ), mMeshValue( NULL ), mDefaultValueSize( default_value_size ), mMeshValueSize( 0 ),
      13                 :       3037 :       mDataSize( size ), dataType( type )
      14                 :            : {
      15         [ +  + ]:       3037 :     if( default_value )
      16                 :            :     {
      17                 :       2236 :         mDefaultValue = malloc( mDefaultValueSize );
      18                 :       2236 :         memcpy( mDefaultValue, default_value, mDefaultValueSize );
      19                 :            :     }
      20 [ +  + ][ +  - ]:       3037 :     if( name ) mTagName = name;
      21                 :       3037 : }
      22                 :            : 
      23                 :       6006 : TagInfo::~TagInfo()
      24                 :            : {
      25                 :       3003 :     free( mDefaultValue );
      26                 :       3003 :     mDefaultValue     = 0;
      27                 :       3003 :     mDefaultValueSize = 0;
      28         [ -  + ]:       3003 : }
      29                 :            : 
      30                 :      36054 : int TagInfo::size_from_data_type( DataType t )
      31                 :            : {
      32                 :            :     static const int sizes[] = { 1, sizeof( int ), sizeof( double ), 1, sizeof( EntityHandle ), 0 };
      33                 :      36054 :     return sizes[t];
      34                 :            : }
      35                 :            : 
      36                 :       1477 : bool TagInfo::equals_default_value( const void* data, int size ) const
      37                 :            : {
      38         [ +  + ]:       1477 :     if( !get_default_value() ) return false;
      39                 :            : 
      40 [ -  + ][ #  # ]:       1360 :     if( variable_length() && size != get_default_value_size() ) return false;
                 [ -  + ]
      41                 :            : 
      42 [ +  - ][ +  + ]:       1360 :     if( !variable_length() && size >= 0 && size != get_size() ) return false;
         [ -  + ][ -  + ]
      43                 :            : 
      44         [ -  + ]:       1360 :     if( get_data_type() == MB_TYPE_BIT )
      45                 :            :     {
      46 [ #  # ][ #  # ]:          0 :         assert( get_size() <= 8 && get_default_value_size() == 1 );
      47                 :          0 :         unsigned char byte1 = *reinterpret_cast< const unsigned char* >( data );
      48                 :          0 :         unsigned char byte2 = *reinterpret_cast< const unsigned char* >( get_default_value() );
      49                 :          0 :         unsigned char mask  = (unsigned char)( ( 1u << get_size() ) - 1 );
      50                 :          0 :         return ( byte1 & mask ) == ( byte2 & mask );
      51                 :            :     }
      52                 :            :     else
      53                 :            :     {
      54                 :       1360 :         return !memcmp( data, get_default_value(), get_default_value_size() );
      55                 :            :     }
      56                 :            : }
      57                 :            : 
      58                 :            : // Check that all lengths are valid multiples of the type size.
      59                 :            : // Returns true if all lengths are valid, false otherwise.
      60                 :          0 : bool TagInfo::check_valid_sizes( const int* sizes, int num_sizes ) const
      61                 :            : {
      62                 :          0 :     const unsigned size = size_from_data_type( get_data_type() );
      63         [ #  # ]:          0 :     if( 1 == size ) return true;
      64                 :            : 
      65                 :          0 :     unsigned sum = 0;
      66         [ #  # ]:          0 :     for( int i = 0; i < num_sizes; ++i )
      67                 :          0 :         sum |= ( (unsigned)sizes[i] ) % size;
      68                 :            : 
      69                 :          0 :     return ( 0 == sum );
      70                 :            : }
      71                 :            : 
      72                 :       1017 : ErrorCode TagInfo::validate_lengths( Error* /* error_handler */, const int* lengths, size_t num_lengths ) const
      73                 :            : {
      74                 :       1017 :     int bits = 0;
      75         [ +  + ]:       1017 :     if( variable_length() )
      76                 :            :     {
      77 [ -  + ][ #  # ]:        997 :         if( !lengths ) { MB_SET_ERR( MB_VARIABLE_DATA_LENGTH, "No size specified for variable-length tag" ); }
         [ #  # ][ #  # ]
         [ #  # ][ #  # ]
      78                 :        997 :         const unsigned type_size = size_from_data_type( get_data_type() );
      79         [ +  + ]:        997 :         if( type_size == 1 ) return MB_SUCCESS;
      80         [ +  + ]:       2074 :         for( size_t i = 0; i < num_lengths; ++i )
      81                 :       1079 :             bits |= lengths[i] % type_size;
      82                 :            :     }
      83         [ +  + ]:         20 :     else if( lengths )
      84                 :            :     {
      85         [ +  + ]:         12 :         for( size_t i = 0; i < num_lengths; ++i )
      86                 :          6 :             bits |= lengths[i] - get_size();
      87                 :            :     }
      88         [ +  - ]:       1015 :     if( 0 == bits ) return MB_SUCCESS;
      89                 :            : 
      90 [ #  # ][ #  # ]:       1017 :     MB_SET_ERR( MB_INVALID_SIZE, "Tag data with invalid size" );
         [ #  # ][ #  # ]
                 [ #  # ]
      91                 :            : }
      92                 :            : 
      93                 :            : }  // namespace moab