utility.cpp

Go to the documentation of this file.

// utility.cpp
//////////////////////////////////////////////////////////////////////
//          (c) Copyright 2001-2002 Brown Deer Technology, LLC.
//                        All rights reserved.
//////////////////////////////////////////////////////////////////////

#ifdef USE_STD
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
#else
#include <iostream.h>
#include <string.h>
#include <algorithm.h>
#endif

#include "utility.h"

void inttohex( int num, char* ptc, int len ) {
   const char* hexdigit="0123456789ABCDEF";
   char* pttmp=(char*)(&num);
   unsigned char c;
   int j=0;

   for(int i = 0; i < min( len, int(sizeof(int) ) ); i++ ) {
#ifdef STORM_RS6000_AIX
      c=pttmp[ sizeof(int) - len + i ];
#endif
#ifdef STORM_x86_LINUX
      c=pttmp[ len - 1 - i ];
#endif
#ifdef STORM_SGI_IRIX
      c=pttmp[ sizeof(int) - len + i ];
#endif
      ptc[j++] = hexdigit[ int( ( c & 0xF0 ) >> 4 ) ];
      ptc[j++] = hexdigit[ int( ( c & 0x0F ) ) ];
   }

   ptc[j]='\0';

}


bytepack::bytepack( const int sizemax ) 
  : _sizemax(sizemax), _size(0) 
{
   _data = new char[ _sizemax + 1 ]; 
   _data[0] = 0;
}

bytepack::bytepack( const bytepack& rhs ) 
  : _sizemax(rhs._sizemax), _size(rhs._size) 
{
   _data = new char[ _sizemax + 1 ]; 
   for( int i = 0; i < rhs._sizemax; ++i ) _data[i] = rhs._data[i];
}

bytepack::~bytepack() { delete [] _data; _data = 0; }

bytepack& bytepack::operator()( const char data, const int size ) 
{
   for( int i = 0; i <= size; i++ ) _data[i] = 0;
   _data[0] = data;
   _size = 1;
   return *this;
}

bytepack& bytepack::operator()( const int data0, const int size ) {
   int data = data0;
   char* ptdata = (char*)(&data);
   for(int i=0;i<=size;i++) _data[i] = 0;
#ifdef STORM_RS6000_AIX
   for(int i = 0; i < min( size, int(sizeof(int)) ); i++ ) {
      _data[i] = ptdata[ sizeof(int) - 1 - i ]; 
   }
   _size = size;
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0; i < min( size, int(sizeof(int)) ); i++ ) {
      _data[i] = ptdata[i]; 
   }
   _size = size;
#endif
#ifdef STORM_SGI_IRIX
   for( int i = 0; i < min( size, int(sizeof(int)) ); i++ ) {
      _data[i] = ptdata[ sizeof(int) - 1 - i ]; 
   }
   _size = size;
#endif
   return *this;
}

bytepack& bytepack::operator()( const float data0, const int size ) {
   float data = data0;
   char* ptdata = (char*)(&data);
   for( int i = 0; i <= size; i++ ) _data[i] = 0;
#ifdef STORM_RS6000_AIX
   for( int i = 0; i < min( size, int(sizeof(float)) ); i++ ) {
      _data[i] = ptdata[i]; 
   }
   _size = size;
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0 ; i < min( size, int(sizeof(float)) ); i++ ) {
      _data[i] = ptdata[ sizeof(float) - 1 - i ]; 
   }
   _size = size;
#endif
#ifdef STORM_SGI_IRIX
   for( i = 0; i < min( size, int(sizeof(float)) ); i++ ) {
      _data[i] = ptdata[i]; 
   }
   _size = size;
#endif
   return *this;
}

bytepack& bytepack::operator()( const double data0, const int size ) {
   double data = data0;
   char* ptdata = (char*)(&data);
   for( int i = 0; i <= size; i++ ) _data[i] = 0;
#ifdef STORM_RS6000_AIX
   for( int i = 0; i < min( size, int(sizeof(double)) ); i++ ) {
      _data[i] = ptdata[i]; 
   }
   _size = size;
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0; i < min( size, int(sizeof(double)) ); i++ ) {
      _data[i] = ptdata[ sizeof(double) - 1 - i ]; 
   }
   _size = size;
#endif
#ifdef STORM_SGI_IRIX
   for( int i = 0; i < min( size, int(sizeof(double)) ); i++ ) {
      _data[i] = ptdata[i]; 
   }
   _size = size;
#endif
   return *this;
}

bytepack& bytepack::operator = ( const bytepack bp ) 
{
   _sizemax = bp._sizemax;
   if ( _data != 0 ) delete [] _data;
   _data = new char[ _sizemax + 1 ]; 
   _size = bp._size;
   for( int i = 0; i < ( _sizemax + 1); ++i ) _data[i] = bp._data[i];
   return *this;
}

bytepack::operator char() { return char(_data[0]); }

bytepack::operator int() {
   int data;
   char* ptdata = (char*)(&data);
   if ((_data[_size-1]&0x80)) {
      for( int i = 0; i < (int)sizeof(int); i++ ) ptdata[i] = 0xFF; 
   }
   else {
      for( int i = 0; i < (int)sizeof(int); i++ ) ptdata[i] = 0x00; 
   }
#ifdef STORM_RS6000_AIX
   for( int i = 0; i < min( _size, int(sizeof(int)) ); i++ ) { 
      ptdata[ sizeof(int) - 1 - i ] = _data[i]; 
   }
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0; i < min( _size, int(sizeof(int)) ); i++ ) { 
      ptdata[i] = _data[i]; 
   }
#endif
#ifdef STORM_SGI_IRIX
   for( int i = 0; i < min( _size, int(sizeof(int)) ); i++ ) { 
      ptdata[ sizeof(int) - 1 - i ] = _data[i]; 
   }
#endif
   return data;
}

bytepack::operator float() {
   float data = 0;
   char* ptdata = (char*)(&data);
#ifdef STORM_RS6000_AIX
   for( int i = 0; i < min( _size, int(sizeof(float)) ); i++ ) { 
      ptdata[i] = _data[i]; 
   }
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0; i < min( _size, int(sizeof(float)) ); i++ ) { 
      ptdata[ sizeof(float) - 1 - i ] = _data[i];
   }
#endif
#ifdef STORM_SGI_IRIX
   for( int i = 0; i < min( _size, int(sizeof(float)) ); i++ ) { 
      ptdata[i] = _data[i]; 
   }
#endif
   return data;
}

bytepack::operator double() {
   double data=0;
   char* ptdata = (char*)(&data);
#ifdef STORM_RS6000_AIX
   for( int i = 0; i < min( _size, int(sizeof(double)) ); i++ ) { 
      ptdata[i] = _data[i]; 
   }
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0; i < min( _size, int(sizeof(double)) ); i++ ) { 
      ptdata[ sizeof(double) - 1 - i ] = _data[i];
   }
#endif
#ifdef STORM_SGI_IRIX
   for( int i = 0; i < min( _size, int(sizeof(double)) ); i++ ) { 
      ptdata[i] = _data[i]; 
   }
#endif
   return data;
}

void bytepack::write( ostream& os ) 
{
   for( int i = 0; i < _size; i++ ) os.put( _data[i] );
}

void bytepack::read( istream& is ) 
{
   for( int i = 0; i < _size; i++ ) is.get( _data[i] );
   _data[ _size ] = 0;
}

ostream& operator << ( ostream& os, bytepack& bp ) 
{
   bp.write( os );
   return os;
}

istream& operator >> ( istream& is, bytepack& bp ) {
   bp.read( is );
   return is;
}

---