KDIS/KDIS/DataTypes/VariableDatum.cpp

   1 /*********************************************************************
   2 Copyright 2013 Karl Jones
   3 All rights reserved.
   4
   5 Redistribution and use in source and binary forms, with or without
   6 modification, are permitted provided that the following conditions are met:
   7
   8 1. Redistributions of source code must retain the above copyright notice, this
   9    list of conditions and the following disclaimer.
  10 2. Redistributions in binary form must reproduce the above copyright notice,
  11    this list of conditions and the following disclaimer in the documentation
  12    and/or other materials provided with the distribution.
  13
  14 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  15 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  16 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  17 DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
  18 ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  19 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  20 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  21 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  23 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24
  25 For Further Information Please Contact me at
  26 Karljj1@yahoo.com
  27 http://p.sf.net/kdis/UserGuide
  28 *********************************************************************/
  29
  30 #include "./VariableDatum.h"
  31 #include <math.h>
  32
  33 //////////////////////////////////////////////////////////////////////////
  34
  35 using namespace std;
  36 using namespace KDIS;
  37 using namespace DATA_TYPE;
  38 using namespace ENUMS;
  39 using namespace UTILS;
  40
  41 //////////////////////////////////////////////////////////////////////////
  42 // Public:
  43 //////////////////////////////////////////////////////////////////////////
  44
  45 VariableDatum::VariableDatum() :
  46     m_ui32DatumLength( 0 ),
  47     m_ui32DatumID( 0 )
  48 {
  49 }
  50
  51 //////////////////////////////////////////////////////////////////////////
  52
  53 VariableDatum::VariableDatum( DatumID ID, const KString & Value )
  54 {
  55     m_ui32DatumID = ID;
  56
  57     SetDatumValue( Value );
  58 }
  59
  60 //////////////////////////////////////////////////////////////////////////
  61
  62 VariableDatum::VariableDatum( DatumID ID, const KOCTET* data, KUINT32 sizeInBits )
  63 {
  64     m_ui32DatumID = ID;
  65
  66     SetDatumValue( data, sizeInBits );
  67 }
  68
  69 //////////////////////////////////////////////////////////////////////////
  70
  71 VariableDatum::VariableDatum( KDataStream & stream )
  72 {
  73     Decode( stream );
  74 }
  75
  76 //////////////////////////////////////////////////////////////////////////
  77
  78 VariableDatum::~VariableDatum()
  79 {
  80 }
  81
  82 //////////////////////////////////////////////////////////////////////////
  83
  84 void VariableDatum::SetDatumID( DatumID ID )
  85 {
  86     m_ui32DatumID = ID;
  87 }
  88
  89 //////////////////////////////////////////////////////////////////////////
  90
  91 DatumID VariableDatum::GetDatumID() const
  92 {
  93     return ( DatumID )m_ui32DatumID;
  94 }
  95
  96 //////////////////////////////////////////////////////////////////////////
  97
  98 KUINT32 VariableDatum::GetDatumLength() const
  99 {
 100     return m_ui32DatumLength;
 101 }
 102
 103 //////////////////////////////////////////////////////////////////////////
 104
 105 KUINT32 VariableDatum::GetPDULength() const
 106 {
 107     return VARIABLE_DATUM_SIZE + ( m_v8DatumValue.size() * 8 );
 108 }
 109
 110 //////////////////////////////////////////////////////////////////////////
 111
 112 void VariableDatum::SetDatumValue( const KString & s )
 113 {
 114     SetDatumValue( s.c_str(), ( s.length() + 1 ) * 8 ); // +1 to allow for terminating NULL ...
 115 }
 116
 117 //////////////////////////////////////////////////////////////////////////
 118
 119 void VariableDatum::SetDatumValue( const KOCTET * data, KUINT32 sizeInBits )
 120 {
 121     m_v8DatumValue.clear();
 122
 123     KUINT32 sizeInOctets = ceil( sizeInBits / 8.0 );
 124     for( KUINT16 i = 0; i < sizeInOctets; )
 125     {
 126         DatumEntry de;
 127
 128         for( KUINT16 j = 0; j < 8 && i < sizeInOctets; ++j, ++i )
 129         {
 130             de.Buffer[j] = data[i];
 131         }
 132         m_v8DatumValue.push_back( de );
 133     }
 134
 135     m_ui32DatumLength = sizeInBits;
 136 }
 137
 138 //////////////////////////////////////////////////////////////////////////
 139
 140 void VariableDatum::GetDatumValueCopyIntoBuffer( KOCTET * Buffer, KUINT16 BufferSize ) const
 141 {
 142     KUINT32 sizeInOctets = ceil( m_ui32DatumLength / 8.0 );
 143
 144     if( BufferSize < sizeInOctets )throw KException( __FUNCTION__, BUFFER_TOO_SMALL );
 145
 146     // Copy the data into the buffer, octet by octet
 147     vector<DatumEntry>::const_iterator citr = m_v8DatumValue.begin();
 148
 149     KUINT16 i = 0;
 150
 151     while( i < sizeInOctets )
 152     {
 153         for( KUINT16 j = 0; i < sizeInOctets && j < 8; ++j, ++i )
 154         {
 155             Buffer[i] = citr->Buffer[j];
 156         }
 157         ++citr;
 158     }
 159 }
 160
 161 //////////////////////////////////////////////////////////////////////////
 162
 163 KString VariableDatum::GetDatumValueAsKString() const
 164 {
 165     KStringStream ss;
 166
 167     vector<DatumEntry>::const_iterator citr =  m_v8DatumValue.begin();
 168     vector<DatumEntry>::const_iterator citrEnd = m_v8DatumValue.end();
 169
 170     KUINT32 i = 0;
 171
 172     KUINT32 ui32LengthInOctets = ceil(m_ui32DatumLength / 8.0);
 173
 174     while( citr != citrEnd )
 175     {
 176         for( KUINT16 j = 0; i < ui32LengthInOctets && j < 8; ++j, ++i )
 177         {
 178             ss << citr->Buffer[j];
 179         }
 180         ++citr;
 181     }
 182
 183     return ss.str();
 184 }
 185
 186 //////////////////////////////////////////////////////////////////////////
 187
 188 vector<KUINT64> VariableDatum::GetDatumValueAsKUINT64() const
 189 {
 190     KBOOL bSwapBytes = !IsMachineBigEndian();
 191
 192     vector<DatumEntry>::const_iterator citr = m_v8DatumValue.begin();
 193     vector<DatumEntry>::const_iterator citrEnd = m_v8DatumValue.end();
 194
 195     vector<KUINT64> m_Return;
 196
 197     KUINT32 ui32CurrentPos = 0;
 198     KUINT32 ui32LengthInOctets = ceil(m_ui32DatumLength / 8.0);
 199
 200     while( citr != citrEnd )
 201     {
 202         if( ( ui32LengthInOctets - ui32CurrentPos ) < 8 )break;
 203
 204         m_Return.push_back( NetToKUINT64( citr->Buffer, bSwapBytes ).m_Value );
 205
 206         ui32CurrentPos += 8;
 207     }
 208
 209     return m_Return;
 210 }
 211
 212 //////////////////////////////////////////////////////////////////////////
 213
 214 vector<KFLOAT64> VariableDatum::GetDatumValueAsKFLOAT64() const
 215 {
 216     KBOOL bSwapBytes = !IsMachineBigEndian();
 217
 218     vector<DatumEntry>::const_iterator citr = m_v8DatumValue.begin();
 219     vector<DatumEntry>::const_iterator citrEnd = m_v8DatumValue.end();
 220
 221     vector<KFLOAT64> m_Return;
 222
 223     KUINT32 ui32CurrentPos = 0;
 224     KUINT32 ui32LengthInOctets = ceil(m_ui32DatumLength / 8.0);
 225
 226     while( citr != citrEnd )
 227     {
 228         if( ( ui32LengthInOctets - ui32CurrentPos ) < 8 )break;
 229
 230         m_Return.push_back( NetToKFLOAT64( citr->Buffer, bSwapBytes ).m_Value );
 231
 232         ui32CurrentPos += 8;
 233     }
 234
 235     return m_Return;
 236 }
 237
 238 //////////////////////////////////////////////////////////////////////////
 239
 240 void VariableDatum::ClearDatumValue()
 241 {
 242     m_v8DatumValue.clear();
 243     m_ui32DatumLength = 0;
 244 }
 245
 246 //////////////////////////////////////////////////////////////////////////
 247
 248 KString VariableDatum::GetAsString() const
 249 {
 250     KStringStream ss;
 251
 252     // For now we return the datum value as a string.
 253     ss << "Variable Datum:"
 254        << "\n\tID:          " << GetEnumAsStringDatumID( m_ui32DatumID )
 255        << "\n\tLength:      " << m_ui32DatumLength
 256        << "\n\tValue(S):    " << GetDatumValueAsKString()
 257        << "\n";
 258
 259     return ss.str();
 260 }
 261
 262 //////////////////////////////////////////////////////////////////////////
 263
 264 void VariableDatum::Decode( KDataStream & stream )
 265 {
 266     if( stream.GetBufferSize() < VARIABLE_DATUM_SIZE )throw KException( __FUNCTION__, NOT_ENOUGH_DATA_IN_BUFFER );
 267
 268     m_v8DatumValue.clear();
 269
 270     stream >> m_ui32DatumID
 271            >> m_ui32DatumLength;
 272
 273     KUINT32 ui32LengthInOctets = ceil(ceil(m_ui32DatumLength / 8.0) / 8.0) * 8;
 274
 275     // Datum length is returned in bits, so we need to convert to octets
 276     for( KUINT16 i = 0; i < ui32LengthInOctets; )
 277     {
 278         DatumEntry de;
 279
 280         for( KUINT16 j = 0; i < ui32LengthInOctets && j < 8; ++j, ++i )
 281         {
 282             KOCTET o;
 283             stream >> o;
 284             de.Buffer[j] = o;
 285         }
 286         m_v8DatumValue.push_back( de );
 287     }
 288 }
 289
 290 //////////////////////////////////////////////////////////////////////////
 291
 292 KDataStream VariableDatum::Encode() const
 293 {
 294     KDataStream stream;
 295
 296     VariableDatum::Encode( stream );
 297
 298     return stream;
 299 }
 300
 301 //////////////////////////////////////////////////////////////////////////
 302
 303 void VariableDatum::Encode( KDataStream & stream ) const
 304 {
 305     stream << m_ui32DatumID
 306            << m_ui32DatumLength;
 307
 308     vector<DatumEntry>::const_iterator citr = m_v8DatumValue.begin();
 309     vector<DatumEntry>::const_iterator citrEnd = m_v8DatumValue.end();
 310
 311     while( citr != citrEnd )
 312     {
 313         for( KUINT16 i = 0; i < 8; ++i )
 314         {
 315             stream << citr->Buffer[i];
 316         }
 317
 318         ++citr;
 319     }
 320 }
 321
 322 //////////////////////////////////////////////////////////////////////////
 323
 324 KBOOL VariableDatum::operator == ( const VariableDatum & Value ) const
 325 {
 326     if( m_ui32DatumID     != Value.m_ui32DatumID )     return false;
 327     if( m_ui32DatumLength != Value.m_ui32DatumLength ) return false;
 328
 329     vector<DatumEntry>::const_iterator citrThis =  m_v8DatumValue.begin(),
 330                                        citrOther = Value.m_v8DatumValue.begin();
 331
 332     while( citrThis != m_v8DatumValue.end() && citrOther != Value.m_v8DatumValue.end() )
 333     {
 334         if( memcmp( citrThis->Buffer, citrOther->Buffer, 8 ) != 0 )return false;
 335         ++citrThis;
 336         ++citrOther;
 337     }
 338     return true;
 339 }
 340
 341 //////////////////////////////////////////////////////////////////////////
 342
 343 KBOOL VariableDatum::operator != ( const VariableDatum & Value ) const
 344 {
 345     return !( *this == Value );
 346 }
 347
 348 //////////////////////////////////////////////////////////////////////////
 349