ZeusBase-Library: ZVariant.h 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     : ZVariant
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 #ifndef ZVariantH
00033 #define ZVariantH
00034 
00035 
00036 #include <zeusbase/System/Interfaces/IZVariant.hpp>
00037 #include <zeusbase/System/ZObject.h>
00038 #include <zeusbase/System/SingleLinkedList.hpp>
00039 #include <zeusbase/System/Serializer.h>
00040 
00041 BEGIN_NAMESPACE_Zeus
00042 
00043 
00044 /***************************************************************************/
00047 /***************************************************************************/
00048 zeusbase_class TZVariant : public TZObject , public IZVariant
00049 {
00050   public :
00051 
00052     /*************************************************************************/
00055     /*************************************************************************/
00056     inline TZVariant()
00057     {
00058       m_bAllocated = false;
00059       m_ArgType = etEmpty;
00060     }
00061 
00062     /*************************************************************************/
00066     /*************************************************************************/
00067     inline TZVariant(Int8 cValue)
00068     {
00069       m_bAllocated = false;
00070       setInt8(cValue);
00071     }
00072 
00073     /*************************************************************************/
00077     /*************************************************************************/
00078     inline TZVariant(Int16 sValue)
00079     {
00080       m_bAllocated = false;
00081       setInt16(sValue);
00082     }
00083 
00084     /*************************************************************************/
00088     /*************************************************************************/
00089     inline TZVariant(int iValue)
00090     {
00091       m_bAllocated = false;
00092       setInt32(iValue);
00093     }
00094 
00095     /*************************************************************************/
00099     /*************************************************************************/
00100     inline TZVariant(Int32 lValue)
00101     {
00102       m_bAllocated = false;
00103       setInt32(lValue);
00104     }
00105 
00106     /*************************************************************************/
00110     /*************************************************************************/
00111     inline TZVariant(Int64 ldValue)
00112     {
00113       m_bAllocated = false;
00114       setInt64(ldValue);
00115     }
00116 
00117     /*************************************************************************/
00121     /*************************************************************************/
00122     inline TZVariant(Uint8 ucValue)
00123     {
00124       m_bAllocated = false;
00125       setUint8(ucValue);
00126     }
00127 
00128     /*************************************************************************/
00132     /*************************************************************************/
00133     inline TZVariant(Uint16 usValue)
00134     {
00135       m_bAllocated = false;
00136       setUint16(usValue);
00137     }
00138 
00139     /*************************************************************************/
00143     /*************************************************************************/
00144     inline TZVariant(unsigned int uiValue)
00145     {
00146       m_bAllocated = false;
00147       setUint32(uiValue);
00148     }
00149 
00150     /*************************************************************************/
00154     /*************************************************************************/
00155     inline TZVariant(Uint32 ulValue)
00156     {
00157       m_bAllocated = false;
00158       setUint32(ulValue);
00159     }
00160 
00161     /*************************************************************************/
00165     /*************************************************************************/
00166     inline TZVariant(Uint64 uldValue)
00167     {
00168       m_bAllocated = false;
00169       setUint64(uldValue);
00170     }
00171     
00172     /*************************************************************************/
00176     /*************************************************************************/
00177     inline TZVariant(Float32 fValue)
00178     {
00179       m_bAllocated = false;
00180       setFloat32(fValue);
00181     }
00182 
00183     /*************************************************************************/
00187     /*************************************************************************/
00188     inline TZVariant(Float64 dValue)
00189     {
00190       m_bAllocated = false;
00191       setFloat64(dValue);
00192     }
00193 
00194     /*************************************************************************/
00198     /*************************************************************************/
00199     inline TZVariant(const char* pValue)
00200     {
00201       m_bAllocated = false;
00202       TString strValue(pValue);
00203       setString(strValue);
00204     }
00205 
00206     /*************************************************************************/
00210     /*************************************************************************/
00211     inline TZVariant(const wchar_t* pValue)
00212     {
00213       m_bAllocated = false;
00214       TString strValue(pValue);
00215       setString(strValue);
00216     }
00217 
00218     /*************************************************************************/
00222     /*************************************************************************/
00223     inline TZVariant(TString strValue)
00224     {
00225       m_bAllocated = false;
00226       setString(strValue);
00227     }
00228 
00229     /*************************************************************************/
00233     /*************************************************************************/
00234     inline TZVariant(const IString& rValue)
00235     {
00236       m_bAllocated = false;
00237       setString(rValue);
00238     }
00239 
00240     /*************************************************************************/
00244     /*************************************************************************/
00245     inline TZVariant(const TByteArray& rValue)
00246     {
00247       m_bAllocated = false;
00248       setByteArray(rValue);
00249     }
00250 
00251     /*************************************************************************/
00255     /*************************************************************************/
00256     inline TZVariant(const ISerializable& rValue)
00257     {
00258       m_bAllocated = false;
00259       setObject(rValue);
00260     }
00261 
00262     /*************************************************************************/
00266     /*************************************************************************/
00267     inline TZVariant(const IList<ISerializable*>& rValue)
00268     {
00269       m_bAllocated = false;
00270       setObjectList(rValue);
00271     }
00272 
00273     /*************************************************************************/
00278     /*************************************************************************/
00279     inline TZVariant(TString strName, Int8 cValue) : TZObject(strName)
00280     {
00281       m_bAllocated = false;
00282       setInt8(cValue);
00283     }
00284 
00285     /*************************************************************************/
00290     /*************************************************************************/
00291     inline TZVariant(TString strName, Int16 sValue) : TZObject(strName)
00292     {
00293       m_bAllocated = false;
00294       setInt16(sValue);
00295     }
00296 
00297     /*************************************************************************/
00302     /*************************************************************************/
00303     inline TZVariant(TString strName, Int32 lValue) : TZObject(strName)
00304     {
00305       m_bAllocated = false;
00306       setInt32(lValue);
00307     }
00308 
00309     /*************************************************************************/
00314     /*************************************************************************/
00315     inline TZVariant(TString strName, Int64 ldValue) : TZObject(strName)
00316     {
00317       m_bAllocated = false;
00318       setInt64(ldValue);
00319     }
00320 
00321     /*************************************************************************/
00326     /*************************************************************************/
00327     inline TZVariant(TString strName, Uint8  ucValue) : TZObject(strName)
00328     {
00329       m_bAllocated = false;
00330       setUint8(ucValue);
00331     }
00332 
00333     /*************************************************************************/
00338     /*************************************************************************/
00339     inline TZVariant(TString strName, Uint16 usValue) : TZObject(strName)
00340     {
00341       m_bAllocated = false;
00342       setUint16(usValue);
00343     }
00344 
00345     /*************************************************************************/
00350     /*************************************************************************/
00351     inline TZVariant(TString strName, Uint32 ulValue) : TZObject(strName)
00352     {
00353       m_bAllocated = false;
00354       setUint32(ulValue);
00355     }
00356 
00357     /*************************************************************************/
00362     /*************************************************************************/
00363     inline TZVariant(TString strName, Uint64 uldValue) : TZObject(strName)
00364     {
00365       m_bAllocated = false;
00366       setUint64(uldValue);
00367     }
00368 
00369     /*************************************************************************/
00374     /*************************************************************************/
00375     inline TZVariant(TString strName, Float32 fValue) : TZObject(strName)
00376     {
00377       m_bAllocated = false;
00378       setFloat32(fValue);
00379     }
00380 
00381     /*************************************************************************/
00386     /*************************************************************************/
00387     inline TZVariant(TString strName, Float64 dValue) : TZObject(strName)
00388     {
00389       m_bAllocated = false;
00390       setFloat64(dValue);
00391     }
00392 
00393     /*************************************************************************/
00398     /*************************************************************************/
00399     inline TZVariant(TString strName, const char* pValue) : TZObject(strName)
00400     {
00401       m_bAllocated = false;
00402       TString strValue(pValue);
00403       setString(strValue);
00404     }
00405 
00406     /*************************************************************************/
00411     /*************************************************************************/
00412     inline TZVariant(TString strName, const wchar_t* pValue) : TZObject(strName)
00413     {
00414       m_bAllocated = false;
00415       TString strValue(pValue);
00416       setString(strValue);
00417     }
00418 
00419     /*************************************************************************/
00424     /*************************************************************************/
00425     inline TZVariant(TString strName, TString strValue) : TZObject(strName)
00426     {
00427       m_bAllocated = false;
00428       setString(strValue);
00429     }
00430 
00431     /*************************************************************************/
00436     /*************************************************************************/
00437     inline TZVariant(TString strName, const IString& rValue) : TZObject(strName)
00438     {
00439       m_bAllocated = false;
00440       setString(rValue);
00441     }
00442 
00443     /*************************************************************************/
00448     /*************************************************************************/
00449     inline TZVariant(TString strName, const TByteArray& rValue) : TZObject(strName)
00450     {
00451       m_bAllocated = false;
00452       setByteArray(rValue);
00453     }
00454 
00455     /*************************************************************************/
00460     /*************************************************************************/
00461     inline TZVariant(TString strName, const ISerializable& rValue) : TZObject(strName)
00462     {
00463       m_bAllocated = false;
00464       setObject(rValue);
00465     }
00466 
00467     /*************************************************************************/
00472     /*************************************************************************/
00473     inline TZVariant(TString strName, const IList<ISerializable*>& rValue) : TZObject(strName)
00474     {
00475       m_bAllocated = false;
00476       setObjectList(rValue);
00477     }
00478 
00479     /*************************************************************************/
00483     /*************************************************************************/
00484     inline TZVariant(const TZVariant& rInpar)
00485      : TZObject(rInpar)
00486        #if defined(__COLINUX__)
00487        , IZVariant(rInpar)
00488        #endif
00489     {
00490       m_bAllocated = false;
00491       this->assign(rInpar);
00492     }
00493 
00494     /*************************************************************************/
00498     /*************************************************************************/
00499     inline TZVariant(const IZVariant& rInpar)
00500     {
00501       m_bAllocated = false;
00502       this->assign(rInpar);
00503     }
00504 
00505     TString toString() const;
00506 
00507 
00508     //Methods of IZVariant
00509     virtual EZVariantType MQUALIFIER getType() const;
00510     virtual void MQUALIFIER getVariantName(IString& rName) const;
00511     virtual Retval MQUALIFIER getInt8(Int8& ri8Ret) const;
00512     virtual Retval MQUALIFIER getInt16(Int16& ri16Ret) const;
00513     virtual Retval MQUALIFIER getInt32(Int32& ri32Ret) const;
00514     virtual Retval MQUALIFIER getInt64(Int64& ri64Ret) const;
00515     virtual Retval MQUALIFIER getUint8(Uint8& rui8Ret) const;
00516     virtual Retval MQUALIFIER getUint16(Uint16& rui16Ret) const;
00517     virtual Retval MQUALIFIER getUint32(Uint32& rui32Ret) const;
00518     virtual Retval MQUALIFIER getUint64(Uint64& rui64Ret) const;
00519     virtual Retval MQUALIFIER getFloat32(Float32& rf32Ret) const;
00520     virtual Retval MQUALIFIER getFloat64(Float64& rf64Ret) const;
00521     virtual Retval MQUALIFIER getRetval(Retval& rRet) const;
00522     virtual Retval MQUALIFIER getTimeval(Timeval& rRet) const;
00523     virtual Retval MQUALIFIER getString(IString& rRet) const;
00524     virtual Retval MQUALIFIER getByteArray(IByteArray& rRet) const;
00525     virtual Retval MQUALIFIER getObject(ISerializable*& rpRet) const;
00526     virtual Retval MQUALIFIER getCastedObject(const InterfaceID& rIfaceID, IZUnknown*& rpRet) const;
00527     virtual Retval MQUALIFIER getObjectList(IList<ISerializable*>& rRet) const;
00528 
00529     virtual void MQUALIFIER setVariantName(const IString& rName);
00530     virtual void MQUALIFIER setInt8(Int8 i8Val);
00531     virtual void MQUALIFIER setInt16(Int16 i16Val);
00532     virtual void MQUALIFIER setInt32(Int32 i32Val);
00533     virtual void MQUALIFIER setInt64(Int64 i64Val);
00534     virtual void MQUALIFIER setUint8(Uint8 ui8Val);
00535     virtual void MQUALIFIER setUint16(Uint16 ui16Val);
00536     virtual void MQUALIFIER setUint32(Uint32 ui32Val);
00537     virtual void MQUALIFIER setUint64(Uint64 ui64Val);
00538     virtual void MQUALIFIER setFloat32(Float32 f32Val);
00539     virtual void MQUALIFIER setFloat64(Float64 f64Val);
00540     virtual void MQUALIFIER setRetval(Retval retVal);
00541     virtual void MQUALIFIER setTimeval(Timeval tmVal);
00542     virtual void MQUALIFIER setString(const IString& rVal);
00543     virtual void MQUALIFIER setByteArray(const IByteArray& rVal);
00544     virtual void MQUALIFIER setObject(const ISerializable& rVal);
00545     virtual void MQUALIFIER setObjectList(const IList<ISerializable*>& rVal);
00546 
00547     virtual Retval MQUALIFIER assign(const IZVariant& rInpar);
00548     virtual bool MQUALIFIER equals(const IZVariant& rInpar) const;
00549     virtual Int MQUALIFIER compareTo(const IZVariant& rInpar) const;
00550     virtual Int MQUALIFIER toInt(Int iDefault = 0) const;
00551     virtual Uint MQUALIFIER toUint(Uint uiDefault = 0) const;
00552     virtual Float MQUALIFIER toFloat(Float fDefault = 0) const;
00553     virtual void MQUALIFIER toString(IString& rValue) const;
00554 
00555     //Methods of ISterializable
00556     SERIAL_START(TZVariant, L"TZVariant")
00557       SERIAL_STRING_GET_SET(getObjName, setObjName)
00558       SERIAL_ENUM(m_ArgType, EZVariantType)
00559       EZVariantType vtType;
00560       if (lMode == 2)
00561       {
00562         vtType = obj_old->m_ArgType;
00563       }
00564       else
00565       {
00566         vtType = obj_new->m_ArgType;
00567         obj_new->m_bAllocated = false;
00568       }
00569       switch(vtType)
00570       {
00571         case etInt8 :
00572           SERIAL_INT8(m_Data.i8Data);
00573         break;
00574 
00575         case etInt16 :
00576           SERIAL_INT16(m_Data.i16Data);
00577         break;
00578 
00579         case etInt32 :
00580           SERIAL_INT32(m_Data.i32Data);
00581         break;
00582 
00583         case etInt64 :
00584           SERIAL_INT64(m_Data.i64Data);
00585         break;
00586 
00587         case etUint8 :
00588           SERIAL_UINT8(m_Data.ui8Data);
00589         break;
00590 
00591         case etUint16 :
00592           SERIAL_UINT16(m_Data.ui16Data);
00593         break;
00594 
00595         case etUint32 :
00596           SERIAL_UINT32(m_Data.ui32Data);
00597         break;
00598 
00599         case etUint64 :
00600           SERIAL_UINT64(m_Data.ui64Data);
00601         break;
00602 
00603         case etFloat32 :
00604           SERIAL_FLOAT32(m_Data.f32Data);
00605         break;
00606 
00607         case etFloat64 :
00608           SERIAL_FLOAT64(m_Data.f64Data);
00609         break;
00610 
00611         case etString :
00612           if (retValue == RET_NOERROR)
00613           {
00614             if (lMode == 2)
00615             {
00616               if (obj_old->m_Data.pStrData != NULL)
00617               {
00618                 TSerializer::serializeString(*stream_out,*obj_old->m_Data.pStrData);
00619               }
00620               else
00621               {
00622                 retValue = RET_REQUEST_FAILED;
00623               }
00624             }
00625             else
00626             {
00627               obj_new->m_Data.pStrData = new TString();
00628               TSerializer::deserializeString(*stream_in,*obj_new->m_Data.pStrData);
00629               obj_new->m_bAllocated = true;
00630             }
00631           }
00632         break;
00633 
00634         case etByteArray :
00635           if (retValue == RET_NOERROR)
00636           {
00637             if (lMode == 2)
00638             {
00639               if (obj_old->m_Data.pArrayData != NULL)
00640               {
00641                 TSerializer::serializeByteArray(*stream_out,*obj_old->m_Data.pArrayData);
00642               }
00643               else
00644               {
00645                 retValue = RET_REQUEST_FAILED;
00646               }
00647             }
00648             else
00649             {
00650               obj_new->m_Data.pArrayData = new TByteArray();
00651               TSerializer::deserializeByteArray(*stream_in,*obj_new->m_Data.pArrayData);
00652               obj_new->m_bAllocated = true;
00653             }
00654           }
00655         break;
00656 
00657         case etObject :
00658           if (retValue == RET_NOERROR)
00659           {
00660             if (lMode == 2)
00661             {
00662               TSerializer::serializeObject(*stream_out, obj_old->m_Data.pObjectData);
00663             }
00664             else
00665             {
00666               if (TSerializer::deserializeObject(*stream_in, INTERFACE_ISerializable, ICAST(obj_new->m_Data.pObjectData)) == RET_NOERROR)
00667               {
00668                 obj_new->m_bAllocated = true;
00669               }
00670               else
00671               {
00672                 obj_new->m_Data.pObjectData = NULL;
00673                 obj_new->m_ArgType = etEmpty;
00674                 obj_new->m_bAllocated = false;
00675               }
00676             }
00677           }
00678         break;
00679 
00680         case etObjectList :
00681           if (retValue == RET_NOERROR)
00682           {
00683             if (lMode == 2)
00684             {
00685               long lCount = obj_old->m_Data.pObjectList->getCount();
00686               TSerializer::serializeCollectionCount(*stream_out, SERIAL_OBJECTLIST_ID, lCount);
00687 
00688               for(int i = 0; i < lCount; i++)
00689               {
00690                 TSerializer::serializeObjectFromCollection(*stream_out, obj_old->m_Data.pObjectList->getItem(i));
00691               }
00692             }
00693             else
00694             {
00695               long lCount = 0;
00696               TSerializer::deserializeCollectionCount(*stream_in, SERIAL_OBJECTLIST_ID, lCount);
00697               obj_new->m_Data.pObjectList = new TSingleLinkedList<ISerializable*>();
00698               for(int i = 0; i < lCount; i++)
00699               {
00700                 ISerializable* pObject = NULL;
00701                 if (TSerializer::deserializeObjectFromCollection(*stream_in, INTERFACE_ISerializable, ICAST(pObject)) == RET_NOERROR)
00702                 {
00703                   obj_new->m_Data.pObjectList->add(pObject);
00704                 }
00705                 else
00706                 {
00707                   obj_new->m_Data.pObjectList->add(NULL);
00708                 }
00709               }
00710               obj_new->m_bAllocated = true;
00711             }
00712           }
00713         break;
00714 
00715         case etEmpty: //fall through
00716         default:
00717         break;
00718       }
00719     SERIAL_END
00720 
00721     //Methods of IZUnknown
00722     MEMORY_MANAGER_DECL
00723 
00724   protected :
00725 
00726     /*************************************************************************/
00729     /*************************************************************************/
00730     inline virtual ~TZVariant()
00731     {
00732       releaseVariant();
00733     }
00734 
00735     /**************************************************************/
00736     /* This union is private and defines the storage of the
00737        variant.
00738     */
00739     /**************************************************************/
00740     union TZVariantData
00741     {
00742       Int8     i8Data;
00743       Int16    i16Data;
00744       Int32    i32Data;
00745       Int64    i64Data;
00746       Uint8    ui8Data;
00747       Uint16   ui16Data;
00748       Uint32   ui32Data;
00749       Uint64   ui64Data;
00750       Float32  f32Data;
00751       Float64  f64Data;
00752       TString* pStrData;
00753 
00754       TByteArray*    pArrayData;
00755       ISerializable* pObjectData;
00756       TSingleLinkedList<ISerializable*>* pObjectList;
00757     };
00758 
00760     EZVariantType m_ArgType;
00762     TZVariantData m_Data;
00764     bool m_bAllocated;
00765 
00766   private :
00767     void releaseVariant();
00768 };
00769 
00770 
00771 /****************************************************************************/
00774 /****************************************************************************/
00775 inline TString TZVariant::toString() const
00776 {
00777   TString strRetval;
00778   toString(strRetval);
00779   return strRetval;
00780 }
00781 
00782 /***************************************************************************/
00785 /***************************************************************************/
00786 inline IZVariant::EZVariantType MQUALIFIER TZVariant::getType() const
00787 {
00788   return m_ArgType;
00789 }
00790 
00791 /***************************************************************************/
00794 /***************************************************************************/
00795 inline void MQUALIFIER TZVariant::getVariantName(IString& rName) const
00796 {
00797   TString strName = getObjName();
00798   rName.assignStr(strName);
00799 }
00800 
00801 /****************************************************************************/
00804 /****************************************************************************/
00805 inline Retval MQUALIFIER TZVariant::getRetval(Retval& rRet) const
00806 {
00807   rRet = TZVariant::toInt();
00808   return RET_NOERROR;
00809 }
00810 
00811 /****************************************************************************/
00814 /****************************************************************************/
00815 inline Retval MQUALIFIER TZVariant::getTimeval(Timeval& rRet) const
00816 {
00817   rRet = TZVariant::toInt();
00818   return RET_NOERROR;
00819 }
00820 
00821 /****************************************************************************/
00824 /****************************************************************************/
00825 inline void MQUALIFIER TZVariant::setRetval(Retval retVal)
00826 {
00827   this->setInt32(retVal);
00828 }
00829 
00830 /****************************************************************************/
00833 /****************************************************************************/
00834 inline void MQUALIFIER TZVariant::setTimeval(Timeval tmVal)
00835 {
00836   this->setInt64(tmVal);
00837 }
00838 
00839 END_NAMESPACE_Zeus
00840 
00841 #endif