ZeusBase-Library: ByteArray.hpp Source File

Go to the documentation of this file.
00001 /*****************************************************************************
00002  * Copyright (C) 2011 by Benjamin Hadorn (b_hadorn@bluewin.ch)
00003  *****************************************************************************
00004  * Project    : Zeus Base Library
00005  * Module     : ByteArray
00006  * Package    : Zeus.ZeusBase.System
00007  * Author     : Benjamin Hadorn
00008  * Date       : 27.12.2011
00009  * System     : Zeus-Framework
00010  *****************************************************************************
00011  * Licence:                                                                  *
00012  *   This library is free software; you can redistribute it and/or modify    *
00013  *   it under the terms of the GNU Lesser General Public License as          *
00014  *   published by the Free Software Foundation; either version               *
00015  *   2.1 of the License, or (at your option) any later version.              *
00016  *                                                                           *
00017  *   This library is distributed in the hope that it will be useful,         *
00018  *   but WITHOUT ANY WARRANTY; without even the implied warranty of          *
00019  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the            *
00020  *   GNU Lesser General Public License for more details.                     *
00021  *                                                                           *
00022  *   You should have received a copy of the GNU Lesser General Public        *
00023  *   License along with this library; if not, write to the Free Software     *
00024  *   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA    *
00025  *****************************************************************************/
00026 
00027 /*****************************************************************************
00028  * Changes:
00029  *  27.12.2011 bha: created zeus 2.0
00030  *****************************************************************************/
00031 
00032 
00033 #ifndef ByteArrayHPP
00034 #define ByteArrayHPP
00035 
00036 #include <zeusbase/System/Interfaces/IByteArray.hpp>
00037 #include <zeusbase/System/ArrayList.hpp>
00038 
00039 BEGIN_NAMESPACE_Zeus
00040 
00041 /*****************************************************************************/
00045 /*****************************************************************************/
00046 class TByteArray : public TArrayList<char>
00047 {
00048   public:
00049     /*************************************************************************/
00053     /*************************************************************************/
00054     inline TByteArray(Int iSize = 20)
00055      : TArrayList<char>(iSize, etShallowCopy)
00056     {
00057     }
00058 
00059     /*************************************************************************/
00063     /*************************************************************************/
00064     inline TByteArray(const char* pArray, Int iSize, bool bAttachPointer = false)
00065      : TArrayList<char>(pArray, iSize, etShallowCopy, bAttachPointer)
00066     {
00067     }
00068 
00069     /*************************************************************************/
00073     /*************************************************************************/
00074     inline TByteArray(const char& rEmptyItem, Int iSize)
00075      : TArrayList<char>(rEmptyItem, iSize, etShallowCopy)
00076     {
00077     }
00078 
00079     /*************************************************************************/
00083     /*************************************************************************/
00084     inline TByteArray(const IByteArray* pList)
00085      : TArrayList<char>(pList)
00086     {
00087     }
00088 
00089     /*************************************************************************/
00093     /*************************************************************************/
00094     inline TByteArray(const IByteArray& rList)
00095      : TArrayList<char>(&rList)
00096     {
00097     }
00098 
00099     /*************************************************************************/
00103     /*************************************************************************/
00104     inline TByteArray(const TByteArray& rList)
00105      : TArrayList<char>(rList)
00106     {
00107     }
00108 
00109     /*************************************************************************/
00113     /*************************************************************************/
00114     inline virtual ~TByteArray()
00115     {
00116     }
00117 
00118     /*************************************************************************/
00122     /*************************************************************************/
00123     inline TByteArray& operator=(const IByteArray& rList)
00124     {
00125       rList.copyToList(*this);
00126       return *this;
00127     }
00128 
00129     /*************************************************************************/
00133     /*************************************************************************/
00134     inline TByteArray& operator=(const TByteArray& rList)
00135     {
00136       rList.copyToList(*this);
00137       return *this;
00138     }
00139 
00140     /*************************************************************************/
00145     /*************************************************************************/
00146     inline Int addRawInt8(Int8 cValue)
00147     {
00148       return add(cValue);
00149     }
00150 
00151     /*************************************************************************/
00156     /*************************************************************************/
00157     inline Int addRawInt16(Int16 sValue)
00158     {
00159       char* pMemory = (char*)(&sValue);
00160       Int iRetval = add(pMemory[0]);
00161       add(pMemory[1]);
00162       return iRetval;
00163     }
00164 
00165     /*************************************************************************/
00170     /*************************************************************************/
00171     inline Int addRawInt32(Int32 lValue)
00172     {
00173       char* pMemory = (char*)(&lValue);
00174       Int iRetval = add(pMemory[0]);
00175       add(pMemory[1]);
00176       add(pMemory[2]);
00177       add(pMemory[3]);
00178       return iRetval;
00179     }
00180 
00181     /*************************************************************************/
00186     /*************************************************************************/
00187     inline Int addRawInt64(Int64 ldValue)
00188     {
00189       char* pMemory = (char*)(&ldValue);
00190       Int iRetval = add(pMemory[0]);
00191       add(pMemory[1]);
00192       add(pMemory[2]);
00193       add(pMemory[3]);
00194       add(pMemory[4]);
00195       add(pMemory[5]);
00196       add(pMemory[6]);
00197       add(pMemory[7]);
00198       return iRetval;
00199     }
00200 
00201     /*************************************************************************/
00206     /*************************************************************************/
00207     inline Int addRawUint8(Uint8 ucValue)
00208     {
00209       return addRawInt8((Int8)ucValue);
00210     }
00211 
00212     /*************************************************************************/
00217     /*************************************************************************/
00218     inline Int addRawUint16(Uint16 usValue)
00219     {
00220       return addRawInt16((Int16)usValue);
00221     }
00222 
00223     /*************************************************************************/
00228     /*************************************************************************/
00229     inline Int addRawUint32(Uint32 ulValue)
00230     {
00231       return addRawInt32((Int32)ulValue);
00232     }
00233 
00234     /*************************************************************************/
00239     /*************************************************************************/
00240     inline Int addRawUint64(Uint64 uldValue)
00241     {
00242       return addRawInt64((Int64)uldValue);
00243     }
00244 
00245     /*************************************************************************/
00250     /*************************************************************************/
00251     inline Int addRawFloat32(Float32 fValue)
00252     {
00253       char* pMemory = (char*)(&fValue);
00254       Int iRetval = add(pMemory[0]);
00255       add(pMemory[1]);
00256       add(pMemory[2]);
00257       add(pMemory[3]);
00258       return iRetval;
00259     }
00260 
00261     /*************************************************************************/
00266     /*************************************************************************/
00267     inline Int addRawFloat64(Float64 dValue)
00268     {
00269       char* pMemory = (char*)(&dValue);
00270       Int iRetval = add(pMemory[0]);
00271       add(pMemory[1]);
00272       add(pMemory[2]);
00273       add(pMemory[3]);
00274       add(pMemory[4]);
00275       add(pMemory[5]);
00276       add(pMemory[6]);
00277       add(pMemory[7]);
00278       return iRetval;
00279     }
00280 
00281     /*************************************************************************/
00284     /*************************************************************************/
00285     inline Int addRawString8(const char* acData)
00286     {
00287       Int iRetval = getCount()+1;
00288       while(*acData)
00289       {
00290         add(*acData);
00291         acData++;
00292       }
00293       add(CONST_INT8(0x00));
00294       return iRetval;
00295     }
00296 
00297     /*************************************************************************/
00302     /*************************************************************************/
00303     inline Int8 getRawInt8(Int iFromIndex) const
00304     {
00305       return (Int8)getItemConst(iFromIndex);
00306     }
00307 
00308     /*************************************************************************/
00313     /*************************************************************************/
00314     inline Int16 getRawInt16(Int iFromIndex) const
00315     {
00316       Int16 cRetval = 0;
00317       if (iFromIndex <= (Int)(getCount() - sizeof(Int16)) &&
00318           iFromIndex >= 0)
00319       {
00320         cRetval = *((Int16*)(getArrayConst() + iFromIndex));
00321       }
00322       return cRetval;
00323     }
00324 
00325     /*************************************************************************/
00330     /*************************************************************************/
00331     inline Int32 getRawInt32(Int iFromIndex)
00332     {
00333       Int32 lRetval = 0;
00334       if (iFromIndex <= (Int)(getCount() - sizeof(Int32)) &&
00335           iFromIndex >= 0)
00336       {
00337         lRetval = *((Int32*)(getArrayConst() + iFromIndex));
00338       }
00339       return lRetval;
00340     }
00341 
00342     /*************************************************************************/
00347     /*************************************************************************/
00348     inline Int64 getRawInt64(Int iFromIndex)
00349     {
00350       Int64 ldRetval = 0;
00351       if (iFromIndex <= (Int)(getCount() - sizeof(Int64)) &&
00352           iFromIndex >= 0)
00353       {
00354         ldRetval = *((Int64*)(getArrayConst() + iFromIndex));
00355       }
00356       return ldRetval;
00357     }
00358 
00359     /*************************************************************************/
00364     /*************************************************************************/
00365     inline Uint8 getRawUint8(Int iFromIndex) const
00366     {
00367       return (Uint8)getRawInt8(iFromIndex);
00368     }
00369 
00370     /*************************************************************************/
00375     /*************************************************************************/
00376     inline Uint16 getRawUint16(Int iFromIndex) const
00377     {
00378       return (Uint16)getRawInt16(iFromIndex);
00379     }
00380 
00381     /*************************************************************************/
00386     /*************************************************************************/
00387     inline Uint32 getRawUint32(Int iFromIndex)
00388     {
00389       return (Uint32)getRawInt32(iFromIndex);
00390     }
00391 
00392     /*************************************************************************/
00397     /*************************************************************************/
00398     inline Uint64 getRawUint64(Int iFromIndex)
00399     {
00400       return (Uint64)getRawInt64(iFromIndex);
00401     }
00402 
00403     /*************************************************************************/
00408     /*************************************************************************/
00409     inline Float32 getRawFloat32(Int iFromIndex)
00410     {
00411       Float32 fRetval = 0;
00412       if (iFromIndex <= (Int)(getCount() - sizeof(Float32)) &&
00413           iFromIndex >= 0)
00414       {
00415         fRetval = *((Float32*)(getArrayConst() + iFromIndex));
00416       }
00417       return fRetval;
00418     }
00419 
00420     /*************************************************************************/
00425     /*************************************************************************/
00426     inline Float64 getRawFloat64(Int iFromIndex)
00427     {
00428       Float64 dRetval = 0;
00429       if (iFromIndex <= (Int)(getCount() - sizeof(Float64)) &&
00430           iFromIndex >= 0)
00431       {
00432         dRetval = *((Float64*)(getArrayConst() + iFromIndex));
00433       }
00434       return dRetval;
00435     }
00436 
00437     /*************************************************************************/
00443     /*************************************************************************/
00444     inline char* getRawString8(Int iFromIndex, Int& riEndIndex)
00445     {
00446       char* pRetval = NULL;
00447 
00448       if (iFromIndex < getCount() &&
00449           iFromIndex >= 0)
00450       {
00451         pRetval    = getArray() + iFromIndex;
00452         riEndIndex = iFromIndex;
00453 
00454         while(*(getArray() + riEndIndex) && riEndIndex < getCount())
00455         {
00456           riEndIndex++;
00457         }
00458       }
00459       return pRetval;
00460     }
00461 
00462     /*************************************************************************/
00467     /*************************************************************************/
00468     inline void setRawInt8(Int iFromIndex, Int8 cValue)
00469     {
00470       if (iFromIndex <= (Int)(getCount() - sizeof(Int8)) &&
00471           iFromIndex >= 0)
00472       {
00473         getArray()[iFromIndex] = cValue;
00474       }
00475     }
00476 
00477     /*************************************************************************/
00482     /*************************************************************************/
00483     inline void setRawInt16(Int iFromIndex, Int16 sValue)
00484     {
00485       if (iFromIndex <= (Int)(getCount() - sizeof(Int16)) &&
00486           iFromIndex >= 0)
00487       {
00488         char* pMemory = (char*)(&sValue);
00489         getArray()[iFromIndex] = pMemory[0];
00490         getArray()[iFromIndex+1] = pMemory[1];
00491       }
00492     }
00493 
00494     /*************************************************************************/
00499     /*************************************************************************/
00500     inline void setRawInt32(Int iFromIndex, Int32 lValue)
00501     {
00502       if (iFromIndex <= (Int)(getCount() - sizeof(Int32)) &&
00503           iFromIndex >= 0)
00504       {
00505         char* pMemory = (char*)(&lValue);
00506         getArray()[iFromIndex] = pMemory[0];
00507         getArray()[iFromIndex+1] = pMemory[1];
00508         getArray()[iFromIndex+2] = pMemory[2];
00509         getArray()[iFromIndex+3] = pMemory[3];
00510       }
00511     }
00512 
00513     /*************************************************************************/
00518     /*************************************************************************/
00519     inline void setRawInt64(Int iFromIndex, Int64 ldValue)
00520     {
00521       if (iFromIndex <= (Int)(getCount() - sizeof(Int64)) &&
00522           iFromIndex >= 0)
00523       {
00524         char* pMemory = (char*)(&ldValue);
00525         getArray()[iFromIndex] = pMemory[0];
00526         getArray()[iFromIndex+1] = pMemory[1];
00527         getArray()[iFromIndex+2] = pMemory[2];
00528         getArray()[iFromIndex+3] = pMemory[3];
00529         getArray()[iFromIndex+4] = pMemory[4];
00530         getArray()[iFromIndex+5] = pMemory[5];
00531         getArray()[iFromIndex+6] = pMemory[6];
00532         getArray()[iFromIndex+7] = pMemory[7];
00533       }
00534     }
00535 
00536     /*************************************************************************/
00541     /*************************************************************************/
00542     inline void setRawFloat32(Int iFromIndex, Float32 fValue)
00543     {
00544       if (iFromIndex <= (Int)(getCount() - sizeof(Float32)) &&
00545           iFromIndex >= 0)
00546       {
00547         char* pMemory = (char*)(&fValue);
00548         getArray()[iFromIndex] = pMemory[0];
00549         getArray()[iFromIndex+1] = pMemory[1];
00550         getArray()[iFromIndex+2] = pMemory[2];
00551         getArray()[iFromIndex+3] = pMemory[3];
00552       }
00553     }
00554 
00555     /*************************************************************************/
00560     /*************************************************************************/
00561     inline void setRawFloat64(Int iFromIndex, Float64 dValue)
00562     {
00563       if (iFromIndex <= (Int)(getCount() - sizeof(Float64)) &&
00564           iFromIndex >= 0)
00565       {
00566         char* pMemory = (char*)(&dValue);
00567         getArray()[iFromIndex] = pMemory[0];
00568         getArray()[iFromIndex+1] = pMemory[1];
00569         getArray()[iFromIndex+2] = pMemory[2];
00570         getArray()[iFromIndex+3] = pMemory[3];
00571         getArray()[iFromIndex+4] = pMemory[4];
00572         getArray()[iFromIndex+5] = pMemory[5];
00573         getArray()[iFromIndex+6] = pMemory[6];
00574         getArray()[iFromIndex+7] = pMemory[7];
00575       }
00576     }
00577 };
00578 
00579 END_NAMESPACE_Zeus
00580 #endif