Line data    Source code

       1             : #include <alma/ASDM/EndianStream.h>
       2             : #define write5(x) write((const char*) &x, sizeof(x))
       3             : 
       4             : using namespace std;
       5             : 
       6             : namespace asdm {
       7             :         
       8           0 :   EndianOSStream::EndianOSStream():byteOrder_(asdm::ByteOrder::Machine_Endianity)  {;}
       9             :   
      10             : 
      11           0 :   EndianOSStream::EndianOSStream(const asdm::ByteOrder* byteOrder):byteOrder_(byteOrder) {;}
      12             : 
      13             :   
      14           0 :   EndianOSStream::~EndianOSStream() { ; }
      15             : 
      16           0 :   const asdm::ByteOrder* EndianOSStream::byteOrder() const {
      17           0 :     return this->byteOrder_;
      18             :   }
      19             : 
      20           0 :   void EndianOSStream::writeBoolean(bool b) {
      21           0 :     write((const char*)&b,sizeof(bool));    
      22           0 :   }
      23             : 
      24           0 :   void EndianOSStream::writeBool(bool b) {
      25           0 :     EndianOSStream::writeBoolean(b);    
      26           0 :   }
      27             : 
      28           0 :   void EndianOSStream::writeByte(char c) {
      29           0 :     write((const char*)&c,sizeof(c));       
      30           0 :   }
      31             : 
      32           0 :   void EndianOSStream::writeShort(short s) {
      33           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity)
      34           0 :       ByteSwap5(s);
      35             :         
      36             :     //  write((const char*)&vn,sizeof(vn));
      37             :     //  write((const char*)&s,sizeof(s));
      38           0 :     write5(s);
      39             :                                 
      40           0 :   }
      41             : 
      42           0 :   void EndianOSStream::writeUShort(unsigned short s) {
      43           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity)
      44           0 :       ByteSwap5(s);
      45           0 :     write5(s);                          
      46           0 :   }
      47             : 
      48             : 
      49           0 :   void EndianOSStream::writeInt(int i) {
      50           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity)
      51           0 :       ByteSwap5(i);
      52           0 :     write5(i);                  
      53           0 :   }
      54             : 
      55           0 :   void EndianOSStream::writeUInt(unsigned int ui) {
      56           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity)    
      57           0 :       ByteSwap5(ui);
      58           0 :     write5(ui);         
      59           0 :   }
      60             : 
      61           0 :   void EndianOSStream::writeLongLong(int64_t li) {
      62           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity)    
      63           0 :       ByteSwap5(li);
      64           0 :     write5(li);         
      65           0 :   }
      66             : 
      67           0 :   void EndianOSStream::writeLong(int64_t li) {
      68           0 :     writeLongLong(li);
      69           0 :   }
      70             : 
      71           0 :   void EndianOSStream::writeULongLong(uint64_t li) {
      72           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity)    
      73           0 :       ByteSwap5(li);
      74           0 :     write5(li);         
      75           0 :   }
      76             : 
      77           0 :   void EndianOSStream::writeFloat(float f) {
      78           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity)    
      79           0 :       ByteSwap5(f);
      80           0 :     write5(f);  
      81           0 :   }
      82             :  
      83           0 :   void EndianOSStream::writeDouble(double d) {
      84           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity)    
      85           0 :       ByteSwap5(d);
      86           0 :     write5(d);          
      87           0 :   }
      88             : 
      89           0 :   void EndianOSStream::writeString(const string& s) {
      90           0 :     writeInt(s.length());
      91           0 :     *this  << s;
      92           0 :   }
      93             : 
      94             : 
      95           0 :   EndianISStream::EndianISStream(const string & s):byteOrder_(asdm::ByteOrder::Machine_Endianity) {
      96           0 :     this->str(s);
      97           0 :   }
      98             : 
      99             : 
     100           0 :   EndianISStream::EndianISStream(const string & s, const asdm::ByteOrder* byteOrder):byteOrder_(byteOrder) {
     101           0 :     this->str(s);
     102           0 :   }
     103             : 
     104             : 
     105           0 :   EndianISStream::~EndianISStream() { ; }
     106             : 
     107             : 
     108           0 :   const asdm::ByteOrder*  EndianISStream::byteOrder() const {
     109           0 :     return this->byteOrder_;
     110             :   }
     111             : 
     112             : 
     113           0 :   bool EndianISStream::readBoolean() {
     114             :     bool result;
     115           0 :     read ((char *) &result, sizeof(bool));
     116           0 :     return result;
     117             :   }
     118             : 
     119           0 :   char EndianISStream::readByte() {
     120             :     char result;
     121           0 :     read(&result, 1);
     122           0 :     return result;
     123             :   }
     124             : 
     125           0 :   short int EndianISStream::readShort() {
     126             :     union u { short i; char c[sizeof(short)]; } un;
     127             : 
     128             : 
     129           0 :     read((char *) &un, sizeof(un));
     130             : 
     131           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {  
     132             :       union v { short i; char c[sizeof(short)]; } vn;   
     133           0 :       vn.c[1] = un.c[0];
     134           0 :       vn.c[0] = un.c[1];
     135           0 :       return vn.i;
     136             :     }
     137             :     else
     138           0 :       return un.i;
     139             :   }
     140             : 
     141           0 :   unsigned short int EndianISStream::readUShort() {
     142             :     union u { unsigned short i; char c[sizeof( unsigned short)]; } un;
     143             : 
     144             : 
     145           0 :     read((char *) &un, sizeof(un));
     146             : 
     147           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {          
     148             :       union v { unsigned short i; char c[sizeof( unsigned short)]; } vn;        
     149           0 :       vn.c[1] = un.c[0];
     150           0 :       vn.c[0] = un.c[1];
     151           0 :       return vn.i;
     152             :     }
     153             :     else
     154           0 :       return un.i;
     155             :   }
     156             : 
     157           0 :   int  EndianISStream::readInt() {
     158             :     union u { int i; char c[sizeof(int)]; } un;
     159             :         
     160           0 :     read((char *) & un, sizeof(un));
     161             : 
     162           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {  
     163             :       union v { int i; char c[sizeof(int)]; } vn;       
     164           0 :       vn.c[3] = un.c[0];
     165           0 :       vn.c[2] = un.c[1];
     166           0 :       vn.c[1] = un.c[2];
     167           0 :       vn.c[0] = un.c[3];        
     168           0 :       return vn.i;
     169             :     }
     170             :     else
     171           0 :       return un.i;
     172             :   }
     173             : 
     174           0 :   unsigned int EndianISStream::readUInt() {
     175             :     union u { unsigned int i; char c[sizeof(unsigned int)]; } un;
     176             :         
     177           0 :     read((char *) & un, sizeof(un));
     178             : 
     179           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {  
     180             :       union v { unsigned int i; char c[sizeof(unsigned int)]; } vn;     
     181           0 :       vn.c[3] = un.c[0];
     182           0 :       vn.c[2] = un.c[1];
     183           0 :       vn.c[1] = un.c[2];
     184           0 :       vn.c[0] = un.c[3];        
     185           0 :       return vn.i;
     186             :     }
     187             :     else
     188           0 :       return un.i;
     189             :   }
     190             : 
     191           0 :   int64_t EndianISStream::readLongLong() {
     192             :     union u {int64_t i; char c[sizeof(int64_t)]; } un;
     193             :         
     194           0 :     read((char *) &un, sizeof(un));
     195             : 
     196           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {
     197             :       union v {int64_t i; char c[sizeof(int64_t)]; } vn;
     198           0 :       vn.c[7] = un.c[0];
     199           0 :       vn.c[6] = un.c[1];
     200           0 :       vn.c[5] = un.c[2];
     201           0 :       vn.c[4] = un.c[3];
     202           0 :       vn.c[3] = un.c[4];
     203           0 :       vn.c[2] = un.c[5];
     204           0 :       vn.c[1] = un.c[6];
     205           0 :       vn.c[0] = un.c[7];        
     206           0 :       return vn.i;
     207             :     }
     208             :     else
     209           0 :       return un.i;
     210             :   }
     211             : 
     212           0 :   int64_t EndianISStream::readLong() {
     213           0 :     return readLongLong();
     214             :   }
     215             : 
     216           0 :   uint64_t EndianISStream::readULongLong() {
     217             :     union u {uint64_t i; char c[sizeof(uint64_t)]; } un;
     218             :         
     219           0 :     read((char *) &un, sizeof(un));
     220             : 
     221           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {          
     222             :       union v {uint64_t i; char c[sizeof(uint64_t)]; } vn;
     223           0 :       vn.c[7] = un.c[0];
     224           0 :       vn.c[6] = un.c[1];
     225           0 :       vn.c[5] = un.c[2];
     226           0 :       vn.c[4] = un.c[3];
     227           0 :       vn.c[3] = un.c[4];
     228           0 :       vn.c[2] = un.c[5];
     229           0 :       vn.c[1] = un.c[6];
     230           0 :       vn.c[0] = un.c[7];        
     231           0 :       return vn.i;
     232             :     }
     233             :     else
     234           0 :       return un.i;
     235             :   }
     236             : 
     237           0 :   float EndianISStream::readFloat() {
     238             :     union u {float  f; char c[sizeof(float)]; } un;
     239             :         
     240           0 :     read((char *) &un, sizeof(un));
     241             : 
     242           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {          
     243             :       union v {float f;  char c[sizeof(float)]; } vn;   
     244           0 :       vn.c[3] = un.c[0];
     245           0 :       vn.c[2] = un.c[1];
     246           0 :       vn.c[1] = un.c[2];
     247           0 :       vn.c[0] = un.c[3];
     248           0 :       return vn.f;
     249             :     }
     250             :     else
     251           0 :       return un.f;
     252             : 
     253             :   }
     254             : 
     255           0 :   double EndianISStream::readDouble() {
     256             :     union u {double  d; char c[sizeof(double)]; } un;
     257             :         
     258           0 :     read((char *) &un, sizeof(un));
     259             : 
     260           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {
     261             :       union v {double d; char c[sizeof(double)]; } vn;                  
     262           0 :       vn.c[7] = un.c[0];
     263           0 :       vn.c[6] = un.c[1];
     264           0 :       vn.c[5] = un.c[2];
     265           0 :       vn.c[4] = un.c[3];
     266           0 :       vn.c[3] = un.c[4];
     267           0 :       vn.c[2] = un.c[5];
     268           0 :       vn.c[1] = un.c[6];
     269           0 :       vn.c[0] = un.c[7];        
     270           0 :       return vn.d;      
     271             :     }
     272             :     else
     273           0 :       return un.d;
     274             :         
     275             : 
     276             :   }
     277             : 
     278           0 :   string EndianISStream::readString() {
     279           0 :     int len = readInt();
     280           0 :     char c[len];
     281           0 :     read(c, len);
     282           0 :     return string(c, len);
     283           0 :   }
     284             : 
     285           0 :   EndianIFStream::EndianIFStream():ifs_p(NULL) {;}
     286           0 :   EndianIFStream::EndianIFStream(ifstream*  ifs_p):ifs_p(ifs_p) {;}
     287           0 :   EndianIFStream::EndianIFStream(ifstream*  ifs_p, const asdm::ByteOrder* byteOrder ):ifs_p(ifs_p), byteOrder_(byteOrder) {;}
     288           0 :   EndianIFStream::~EndianIFStream() {;}
     289             : 
     290           0 :   const asdm::ByteOrder*  EndianIFStream::byteOrder() const {
     291           0 :     return this->byteOrder_;
     292             :   }
     293             : 
     294           0 :   bool EndianIFStream::readBoolean() {
     295             :     bool result;
     296           0 :     ifs_p->read ((char *) &result, sizeof(bool));
     297           0 :     return result;
     298             :   }
     299             : 
     300           0 :   char EndianIFStream::readByte() {
     301             :     char result;
     302           0 :     ifs_p->read(&result, 1);
     303           0 :     return result;
     304             :   }
     305             : 
     306           0 :   short int EndianIFStream::readShort() {
     307             :     union u { short i; char c[sizeof(short)]; } un;
     308             : 
     309             : 
     310           0 :     ifs_p->read((char *) &un, sizeof(un));
     311             : 
     312           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {  
     313             :       union v { short i; char c[sizeof(short)]; } vn;   
     314           0 :       vn.c[1] = un.c[0];
     315           0 :       vn.c[0] = un.c[1];
     316           0 :       return vn.i;
     317             :     }
     318             :     else
     319           0 :       return un.i;
     320             :   }
     321             : 
     322           0 :   unsigned short int EndianIFStream::readUShort() {
     323             :     union u { unsigned short i; char c[sizeof( unsigned short)]; } un;
     324             : 
     325             : 
     326           0 :     ifs_p->read((char *) &un, sizeof(un));
     327             : 
     328           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {          
     329             :       union v { unsigned short i; char c[sizeof( unsigned short)]; } vn;        
     330           0 :       vn.c[1] = un.c[0];
     331           0 :       vn.c[0] = un.c[1];
     332           0 :       return vn.i;
     333             :     }
     334             :     else
     335           0 :       return un.i;
     336             :   }
     337             : 
     338           0 :   int  EndianIFStream::readInt() {
     339             :     union u { int i; char c[sizeof(int)]; } un;
     340             :         
     341           0 :     ifs_p->read((char *) & un, sizeof(un));
     342             : 
     343           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {  
     344             :       union v { int i; char c[sizeof(int)]; } vn;       
     345           0 :       vn.c[3] = un.c[0];
     346           0 :       vn.c[2] = un.c[1];
     347           0 :       vn.c[1] = un.c[2];
     348           0 :       vn.c[0] = un.c[3];        
     349           0 :       return vn.i;
     350             :     }
     351             :     else
     352           0 :       return un.i;
     353             :   }
     354             : 
     355           0 :   unsigned int EndianIFStream::readUInt() {
     356             :     union u { unsigned int i; char c[sizeof(unsigned int)]; } un;
     357             :         
     358           0 :     ifs_p->read((char *) & un, sizeof(un));
     359             : 
     360           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {  
     361             :       union v { unsigned int i; char c[sizeof(unsigned int)]; } vn;     
     362           0 :       vn.c[3] = un.c[0];
     363           0 :       vn.c[2] = un.c[1];
     364           0 :       vn.c[1] = un.c[2];
     365           0 :       vn.c[0] = un.c[3];        
     366           0 :       return vn.i;
     367             :     }
     368             :     else
     369           0 :       return un.i;
     370             :   }
     371             : 
     372           0 :   int64_t EndianIFStream::readLongLong() {
     373             :     union u {int64_t i; char c[sizeof(int64_t)]; } un;
     374             :         
     375           0 :     ifs_p->read((char *) &un, sizeof(un));
     376             : 
     377           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {
     378             :       union v {int64_t i; char c[sizeof(int64_t)]; } vn;
     379           0 :       vn.c[7] = un.c[0];
     380           0 :       vn.c[6] = un.c[1];
     381           0 :       vn.c[5] = un.c[2];
     382           0 :       vn.c[4] = un.c[3];
     383           0 :       vn.c[3] = un.c[4];
     384           0 :       vn.c[2] = un.c[5];
     385           0 :       vn.c[1] = un.c[6];
     386           0 :       vn.c[0] = un.c[7];        
     387           0 :       return vn.i;
     388             :     }
     389             :     else
     390           0 :       return un.i;
     391             :   }
     392             : 
     393           0 :   int64_t EndianIFStream::readLong() {
     394           0 :     return readLongLong();
     395             :   }
     396             : 
     397           0 :   uint64_t EndianIFStream::readULongLong() {
     398             :     union u {uint64_t i; char c[sizeof(uint64_t)]; } un;
     399             :         
     400           0 :     ifs_p->read((char *) &un, sizeof(un));
     401             : 
     402           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {          
     403             :       union v {uint64_t i; char c[sizeof(uint64_t)]; } vn;
     404           0 :       vn.c[7] = un.c[0];
     405           0 :       vn.c[6] = un.c[1];
     406           0 :       vn.c[5] = un.c[2];
     407           0 :       vn.c[4] = un.c[3];
     408           0 :       vn.c[3] = un.c[4];
     409           0 :       vn.c[2] = un.c[5];
     410           0 :       vn.c[1] = un.c[6];
     411           0 :       vn.c[0] = un.c[7];        
     412           0 :       return vn.i;
     413             :     }
     414             :     else
     415           0 :       return un.i;
     416             :   }
     417             : 
     418           0 :   float EndianIFStream::readFloat() {
     419             :     union u {float  f; char c[sizeof(float)]; } un;
     420             :         
     421           0 :     ifs_p->read((char *) &un, sizeof(un));
     422             : 
     423           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {          
     424             :       union v {float f;  char c[sizeof(float)]; } vn;   
     425           0 :       vn.c[3] = un.c[0];
     426           0 :       vn.c[2] = un.c[1];
     427           0 :       vn.c[1] = un.c[2];
     428           0 :       vn.c[0] = un.c[3];
     429           0 :       return vn.f;
     430             :     }
     431             :     else
     432           0 :       return un.f;
     433             : 
     434             :   }
     435             : 
     436           0 :   double EndianIFStream::readDouble() {
     437             :     union u {double  d; char c[sizeof(double)]; } un;
     438             :         
     439           0 :     ifs_p->read((char *) &un, sizeof(un));
     440             : 
     441           0 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {
     442             :       union v {double d; char c[sizeof(double)]; } vn;                  
     443           0 :       vn.c[7] = un.c[0];
     444           0 :       vn.c[6] = un.c[1];
     445           0 :       vn.c[5] = un.c[2];
     446           0 :       vn.c[4] = un.c[3];
     447           0 :       vn.c[3] = un.c[4];
     448           0 :       vn.c[2] = un.c[5];
     449           0 :       vn.c[1] = un.c[6];
     450           0 :       vn.c[0] = un.c[7];        
     451           0 :       return vn.d;      
     452             :     }
     453             :     else
     454           0 :       return un.d;
     455             :         
     456             : 
     457             :   }
     458             : 
     459           0 :   string EndianIFStream::readString() {
     460           0 :     int len = readInt();
     461           0 :     char c[len];
     462           0 :     ifs_p->read(c, len);
     463           0 :     return string(c, len);
     464           0 :   }
     465             : 
     466           0 :   BinaryAttributeReaderFunctor::~BinaryAttributeReaderFunctor() {}
     467             : 
     468             : } // end namespace asdm
     469             : 
     470             :