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          22 :   EndianOSStream::EndianOSStream(const asdm::ByteOrder* byteOrder):byteOrder_(byteOrder) {;}
      12             : 
      13             :   
      14          22 :   EndianOSStream::~EndianOSStream() { ; }
      15             : 
      16           0 :   const asdm::ByteOrder* EndianOSStream::byteOrder() const {
      17           0 :     return this->byteOrder_;
      18             :   }
      19             : 
      20      398708 :   void EndianOSStream::writeBoolean(bool b) {
      21      398708 :     write((const char*)&b,sizeof(bool));    
      22      398708 :   }
      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      144384 :   void EndianOSStream::writeInt(int i) {
      50      144384 :     if ( byteOrder_ != ByteOrder::Machine_Endianity)
      51           0 :       ByteSwap5(i);
      52      144384 :     write5(i);                  
      53      144384 :   }
      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       57313 :   void EndianOSStream::writeLongLong(int64_t li) {
      62       57313 :     if ( byteOrder_ != ByteOrder::Machine_Endianity)    
      63           0 :       ByteSwap5(li);
      64       57313 :     write5(li);         
      65       57313 :   }
      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      451024 :   void EndianOSStream::writeDouble(double d) {
      84      451024 :     if ( byteOrder_ != ByteOrder::Machine_Endianity)    
      85           0 :       ByteSwap5(d);
      86      451024 :     write5(d);          
      87      451024 :   }
      88             : 
      89       57151 :   void EndianOSStream::writeString(const string& s) {
      90       57151 :     writeInt(s.length());
      91       57151 :     *this  << s;
      92       57151 :   }
      93             : 
      94             : 
      95           0 :   EndianISStream::EndianISStream(const string & s):byteOrder_(asdm::ByteOrder::Machine_Endianity) {
      96           0 :     this->str(s);
      97           0 :   }
      98             : 
      99             : 
     100          47 :   EndianISStream::EndianISStream(const string & s, const asdm::ByteOrder* byteOrder):byteOrder_(byteOrder) {
     101          47 :     this->str(s);
     102          47 :   }
     103             : 
     104             : 
     105          47 :   EndianISStream::~EndianISStream() { ; }
     106             : 
     107             : 
     108           0 :   const asdm::ByteOrder*  EndianISStream::byteOrder() const {
     109           0 :     return this->byteOrder_;
     110             :   }
     111             : 
     112             : 
     113      625904 :   bool EndianISStream::readBoolean() {
     114             :     bool result;
     115      625904 :     read ((char *) &result, sizeof(bool));
     116      625904 :     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     1229385 :   int  EndianISStream::readInt() {
     158             :     union u { int i; char c[sizeof(int)]; } un;
     159             :         
     160     1229385 :     read((char *) & un, sizeof(un));
     161             : 
     162     1229385 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {  
     163             :       union v { int i; char c[sizeof(int)]; } vn;       
     164     1223986 :       vn.c[3] = un.c[0];
     165     1223986 :       vn.c[2] = un.c[1];
     166     1223986 :       vn.c[1] = un.c[2];
     167     1223986 :       vn.c[0] = un.c[3];        
     168     1223986 :       return vn.i;
     169             :     }
     170             :     else
     171        5399 :       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      281572 :   int64_t EndianISStream::readLongLong() {
     192             :     union u {int64_t i; char c[sizeof(int64_t)]; } un;
     193             :         
     194      281572 :     read((char *) &un, sizeof(un));
     195             : 
     196      281572 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {
     197             :       union v {int64_t i; char c[sizeof(int64_t)]; } vn;
     198      279492 :       vn.c[7] = un.c[0];
     199      279492 :       vn.c[6] = un.c[1];
     200      279492 :       vn.c[5] = un.c[2];
     201      279492 :       vn.c[4] = un.c[3];
     202      279492 :       vn.c[3] = un.c[4];
     203      279492 :       vn.c[2] = un.c[5];
     204      279492 :       vn.c[1] = un.c[6];
     205      279492 :       vn.c[0] = un.c[7];        
     206      279492 :       return vn.i;
     207             :     }
     208             :     else
     209        2080 :       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   391422392 :   double EndianISStream::readDouble() {
     256             :     union u {double  d; char c[sizeof(double)]; } un;
     257             :         
     258   391422392 :     read((char *) &un, sizeof(un));
     259             : 
     260   391422392 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {
     261             :       union v {double d; char c[sizeof(double)]; } vn;                  
     262   391413176 :       vn.c[7] = un.c[0];
     263   391413176 :       vn.c[6] = un.c[1];
     264   391413176 :       vn.c[5] = un.c[2];
     265   391413176 :       vn.c[4] = un.c[3];
     266   391413176 :       vn.c[3] = un.c[4];
     267   391413176 :       vn.c[2] = un.c[5];
     268   391413176 :       vn.c[1] = un.c[6];
     269   391413176 :       vn.c[0] = un.c[7];        
     270   391413176 :       return vn.d;      
     271             :     }
     272             :     else
     273        9216 :       return un.d;
     274             :         
     275             : 
     276             :   }
     277             : 
     278       78962 :   string EndianISStream::readString() {
     279      157924 :     int len = readInt();
     280       78962 :     char c[len];
     281       78962 :     read(c, len);
     282      157924 :     return string(c, len);
     283             :   }
     284             : 
     285          13 :   EndianIFStream::EndianIFStream():ifs_p(NULL) {;}
     286           0 :   EndianIFStream::EndianIFStream(ifstream*  ifs_p):ifs_p(ifs_p) {;}
     287          13 :   EndianIFStream::EndianIFStream(ifstream*  ifs_p, const asdm::ByteOrder* byteOrder ):ifs_p(ifs_p), byteOrder_(byteOrder) {;}
     288          26 :   EndianIFStream::~EndianIFStream() {;}
     289             : 
     290           0 :   const asdm::ByteOrder*  EndianIFStream::byteOrder() const {
     291           0 :     return this->byteOrder_;
     292             :   }
     293             : 
     294    13630992 :   bool EndianIFStream::readBoolean() {
     295             :     bool result;
     296    13630992 :     ifs_p->read ((char *) &result, sizeof(bool));
     297    13630992 :     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    31805791 :   int  EndianIFStream::readInt() {
     339             :     union u { int i; char c[sizeof(int)]; } un;
     340             :         
     341    31805791 :     ifs_p->read((char *) & un, sizeof(un));
     342             : 
     343    31805791 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {  
     344             :       union v { int i; char c[sizeof(int)]; } vn;       
     345    31805791 :       vn.c[3] = un.c[0];
     346    31805791 :       vn.c[2] = un.c[1];
     347    31805791 :       vn.c[1] = un.c[2];
     348    31805791 :       vn.c[0] = un.c[3];        
     349    31805791 :       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     9087328 :   int64_t EndianIFStream::readLongLong() {
     373             :     union u {int64_t i; char c[sizeof(int64_t)]; } un;
     374             :         
     375     9087328 :     ifs_p->read((char *) &un, sizeof(un));
     376             : 
     377     9087328 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {
     378             :       union v {int64_t i; char c[sizeof(int64_t)]; } vn;
     379     9087328 :       vn.c[7] = un.c[0];
     380     9087328 :       vn.c[6] = un.c[1];
     381     9087328 :       vn.c[5] = un.c[2];
     382     9087328 :       vn.c[4] = un.c[3];
     383     9087328 :       vn.c[3] = un.c[4];
     384     9087328 :       vn.c[2] = un.c[5];
     385     9087328 :       vn.c[1] = un.c[6];
     386     9087328 :       vn.c[0] = un.c[7];        
     387     9087328 :       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    27261984 :   float EndianIFStream::readFloat() {
     419             :     union u {float  f; char c[sizeof(float)]; } un;
     420             :         
     421    27261984 :     ifs_p->read((char *) &un, sizeof(un));
     422             : 
     423    27261984 :     if ( byteOrder_ != ByteOrder::Machine_Endianity) {          
     424             :       union v {float f;  char c[sizeof(float)]; } vn;   
     425    27261984 :       vn.c[3] = un.c[0];
     426    27261984 :       vn.c[2] = un.c[1];
     427    27261984 :       vn.c[1] = un.c[2];
     428    27261984 :       vn.c[0] = un.c[3];
     429    27261984 :       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     9087458 :   string EndianIFStream::readString() {
     460    18174916 :     int len = readInt();
     461     9087458 :     char c[len];
     462     9087458 :     ifs_p->read(c, len);
     463    18174916 :     return string(c, len);
     464             :   }
     465             : 
     466           0 :   BinaryAttributeReaderFunctor::~BinaryAttributeReaderFunctor() {}
     467             : 
     468             : } // end namespace asdm
     469             : 
     470             :