DCFbytepack.cpp

Go to the documentation of this file.

// DCFbytepack.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 "DCFbytepack.h"

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

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

bytepack& bytepack::operator()( const char data, const int size ) 
{
   for( int i = 0; i <= size; i++ ) _pt[i] = 0;
   _pt[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++) _pt[i] = 0;
#ifdef STORM_RS6000_AIX
   for(int i = 0; i < min( size, int(sizeof(int)) ); i++ ) {
      _pt[i] = ptdata[ sizeof(int) - 1 - i ]; 
   }
   _size = size;
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0; i < min( size, int(sizeof(int)) ); i++ ) {
      _pt[i] = ptdata[i]; 
   }
   _size = size;
#endif
#ifdef STORM_SGI_IRIX
   for( int i = 0; i < min( size, int(sizeof(int)) ); i++ ) {
      _pt[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++ ) _pt[i] = 0;
#ifdef STORM_RS6000_AIX
   for( int i = 0; i < min( size, int(sizeof(float)) ); i++ ) {
      _pt[i] = ptdata[i]; 
   }
   _size = size;
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0 ; i < min( size, int(sizeof(float)) ); i++ ) {
      _pt[i] = ptdata[ sizeof(float) - 1 - i ]; 
   }
   _size = size;
#endif
#ifdef STORM_SGI_IRIX
   for( i = 0; i < min( size, int(sizeof(float)) ); i++ ) {
      _pt[i] = ptdata[i]; 
   }
   _size = size;
#endif
//#ifdef STORM_DEBUG
//   cout << "bytepack::operator(): float : data0 _size _pt[] "
//      << data0 << ' ' << _size << ' ';
//   for(i=0;i<_size;i++) { cout << int( (unsigned char)(_pt[i]) ) << ' '; }
//   cout << '\n';
//#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++ ) _pt[i] = 0;
#ifdef STORM_RS6000_AIX
   for( int i = 0; i < min( size, int(sizeof(double)) ); i++ ) {
      _pt[i] = ptdata[i]; 
   }
   _size = size;
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0; i < min( size, int(sizeof(double)) ); i++ ) {
      _pt[i] = ptdata[ sizeof(double) - 1 - i ]; 
   }
   _size = size;
#endif
#ifdef STORM_SGI_IRIX
   for( int i = 0; i < min( size, int(sizeof(double)) ); i++ ) {
      _pt[i] = ptdata[i]; 
   }
   _size = size;
#endif
   return *this;
};

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

bytepack::operator int() {
   int data;
   char* ptdata = (char*)(&data);
   if ((_pt[_size-1]&0x80)) {
      for( int i = 0; i < sizeof(int); i++ ) ptdata[i] = 0xFF; 
   }
   else {
      for( int i = 0; i < 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 ] = _pt[i]; 
   }
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0; i < min( _size, int(sizeof(int)) ); i++ ) { 
      ptdata[i] = _pt[i]; 
   }
#endif
#ifdef STORM_SGI_IRIX
   for( int i = 0; i < min( _size, int(sizeof(int)) ); i++ ) { 
      ptdata[ sizeof(int) - 1 - i ] = _pt[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] = _pt[i]; 
   }
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0; i < min( _size, int(sizeof(float)) ); i++ ) { 
      ptdata[ sizeof(float) - 1 - i ] = _pt[i];
   }
#endif
#ifdef STORM_SGI_IRIX
   for( int i = 0; i < min( _size, int(sizeof(float)) ); i++ ) { 
      ptdata[i] = _pt[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] = _pt[i]; 
   }
#endif
#ifdef STORM_x86_LINUX
   for( int i = 0; i < min( _size, int(sizeof(double)) ); i++ ) { 
      ptdata[ sizeof(double) - 1 - i ] = _pt[i];
   }
#endif
#ifdef STORM_SGI_IRIX
   for( int i = 0; i < min( _size, int(sizeof(double)) ); i++ ) { 
      ptdata[i] = _pt[i]; 
   }
#endif
   return data;
};

ostream& operator << ( ostream& os, bytepack& bp ) {
   for( int i = 0; i < bp._size; i++ ) { os.put( bp._pt[i] ); }
//#ifdef STORM_DEBUG
//   cout << "bytepack:operator<<: ";
//   for(i=0;i<bp._size;i++) { cout << int( (unsigned char)(bp._pt[i]) ); }
//   cout << '\n';
//#endif
   return os;
};

istream& operator >> ( istream& is, bytepack& bp ) {
   for( int i = 0; i < bp._size; i++ ) { is.get( bp._pt[i] ); }
   bp._pt[ bp._size ] = 0;
   return is;
};

---