ZeusBase-Library: ZSimpleVariant.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     : ZSimpleVariant
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 ZSimpleVariantHPP
00033 #define ZSimpleVariantHPP
00034 
00035 #include <zeusbase/System/String.h>
00036 #include <zeusbase/System/Float.h>
00037 
00038 BEGIN_NAMESPACE_Zeus
00039 
00040 /**************************************************************************/
00049 /**************************************************************************/
00050 class TZSimpleVariant
00051 {
00052   public:
00053     /**********************************************************************/
00056     /**********************************************************************/
00057     enum EDataType
00058     {
00059       etEmpty  = -1,
00060       etFloat  = 0,
00061       etInt    = 1,
00062       etUint32 = 2,
00063       etBool   = 3,
00064       etString = 4,
00065       etUint8  = 5,
00066       etUint16 = 6,
00067     };
00068 
00069     /**********************************************************************/
00072     /**********************************************************************/
00073     union TZSimpleVariantData
00074     {
00075       Int      iData;
00076       Uint8    ucData;
00077       Uint16   usData;
00078       Uint32   ulData;
00079       bool     bData;
00080       Float    fData;
00081       TString* pstrData;
00082     };
00083 
00084     /**********************************************************************/
00087     /**********************************************************************/
00088     inline TZSimpleVariant()
00089     {
00090       m_Data.pstrData = NULL;
00091       m_eDataType = etEmpty;
00092     }
00093 
00094     /**********************************************************************/
00097     /**********************************************************************/
00098     inline TZSimpleVariant(int iValue)
00099     {
00100       m_Data.iData = iValue;
00101       m_eDataType  = etInt;
00102     }
00103 
00104     /**********************************************************************/
00107     /**********************************************************************/
00108     inline TZSimpleVariant(Int iValue)
00109     {
00110       m_Data.iData = iValue;
00111       m_eDataType  = etInt;
00112     }
00113 
00114     /**********************************************************************/
00117     /**********************************************************************/
00118     inline TZSimpleVariant(unsigned int uiValue)
00119     {
00120       m_Data.ulData = uiValue;
00121       m_eDataType   = etUint32;
00122     }
00123 
00124     /**********************************************************************/
00127     /**********************************************************************/
00128     inline TZSimpleVariant(Uint8 ucValue)
00129     {
00130       m_Data.iData  = 0;
00131       m_Data.ucData = ucValue;
00132       m_eDataType   = etUint8;
00133     }
00134 
00135     /**********************************************************************/
00138     /**********************************************************************/
00139     inline TZSimpleVariant(Uint16 usValue)
00140     {
00141       m_Data.usData = usValue;
00142       m_eDataType   = etUint16;
00143     }
00144 
00145     /**********************************************************************/
00148     /**********************************************************************/
00149     inline TZSimpleVariant(Uint32 ulValue)
00150     {
00151       m_Data.ulData = ulValue;
00152       m_eDataType   = etUint32;
00153     }
00154 
00155     /**********************************************************************/
00158     /**********************************************************************/
00159     inline TZSimpleVariant(const Float& rfValue)
00160     {
00161       m_Data.fData = rfValue;
00162       m_eDataType  = etFloat;
00163     }
00164 
00165     /**********************************************************************/
00168     /**********************************************************************/
00169     inline TZSimpleVariant(const IString& rstrValue)
00170     {
00171       m_Data.pstrData = new TString(rstrValue);
00172       m_eDataType  = etString;
00173     }
00174 
00175     /**********************************************************************/
00178     /**********************************************************************/
00179     inline TZSimpleVariant(const TString& rstrValue)
00180     {
00181       m_Data.pstrData = new TString(rstrValue);
00182       m_eDataType  = etString;
00183     }
00184 
00185     /**********************************************************************/
00188     /**********************************************************************/
00189     inline TZSimpleVariant(const wchar_t* pValue)
00190     {
00191       m_Data.pstrData = new TString(pValue);
00192       m_eDataType  = etString;
00193     }
00194 
00195     /**********************************************************************/
00198     /**********************************************************************/
00199     inline TZSimpleVariant(bool bValue)
00200     {
00201       m_Data.bData = bValue;
00202       m_eDataType  = etBool;
00203     }
00204 
00205     /**********************************************************************/
00208     /**********************************************************************/
00209     inline TZSimpleVariant(const TZSimpleVariant& rInpar)
00210     {
00211       m_eDataType = etEmpty;
00212       assign(rInpar);
00213     }
00214 
00215     /**********************************************************************/
00218     /**********************************************************************/
00219     inline virtual ~TZSimpleVariant()
00220     {
00221       releaseInstances();
00222     }
00223 
00224     /**********************************************************************/
00227     /**********************************************************************/
00228     inline void assign(const TZSimpleVariant& rInpar)
00229     {
00230       releaseInstances(); //release old data
00231       m_eDataType = rInpar.m_eDataType;
00232       if (m_eDataType == etString)
00233       {
00234         m_Data.pstrData = new TString(rInpar.m_Data.pstrData);
00235       }
00236       else
00237       {
00238         m_Data = rInpar.m_Data;
00239       }
00240     }
00241 
00242     /**********************************************************************/
00245     /**********************************************************************/
00246     inline void assignInt(Int iValue)
00247     {
00248       releaseInstances(); //release old data
00249       m_Data.iData = iValue;
00250       m_eDataType  = etInt;
00251     }
00252 
00253     /**********************************************************************/
00256     /**********************************************************************/
00257     inline void assignUint8(Uint8 ucValue)
00258     {
00259       releaseInstances(); //release old data
00260       m_Data.ucData = ucValue;
00261       m_eDataType   = etUint8;
00262     }
00263 
00264     /**********************************************************************/
00267     /**********************************************************************/
00268     inline void assignUint16(Uint16 usValue)
00269     {
00270       releaseInstances(); //release old data
00271       m_Data.usData = usValue;
00272       m_eDataType   = etUint16;
00273     }
00274 
00275     /**********************************************************************/
00278     /**********************************************************************/
00279     inline void assignUint32(Uint32 ulValue)
00280     {
00281       releaseInstances(); //release old data
00282       m_Data.ulData = ulValue;
00283       m_eDataType   = etUint32;
00284     }
00285 
00286     /**********************************************************************/
00289     /**********************************************************************/
00290     inline void assignBool(bool bValue)
00291     {
00292       releaseInstances(); //release old data
00293       m_Data.bData = bValue;
00294       m_eDataType  = etBool;
00295     }
00296 
00297     /**********************************************************************/
00300     /**********************************************************************/
00301     inline void assignFloat(const Float& rfValue)
00302     {
00303       releaseInstances(); //release old data
00304       m_Data.fData = rfValue;
00305       m_eDataType  = etFloat;
00306     }
00307 
00308     /**********************************************************************/
00311     /**********************************************************************/
00312     inline void assignString(const IString& rstrValue)
00313     {
00314       releaseInstances(); //release old data
00315       m_Data.pstrData = new TString(rstrValue);
00316       m_eDataType     = etString;
00317     }
00318 
00319     /**********************************************************************/
00322     /**********************************************************************/
00323     bool convert(EDataType eNewDataType)
00324     {
00325       bool bRetval = (eNewDataType == m_eDataType);
00326 
00327       if (!bRetval)
00328       {
00329         switch(eNewDataType)
00330         {
00331           //-------------------------------------------------------------
00332           case etEmpty:
00333             releaseInstances();
00334             m_eDataType = etEmpty;
00335             bRetval = true;
00336           break;
00337 
00338           //-------------------------------------------------------------
00339           case etInt:
00340           {
00341             bool bError = false;
00342             Int iData = toInt(&bError);
00343             if (!bError)
00344             {
00345               releaseInstances();
00346               m_eDataType  = etInt;
00347               m_Data.iData = iData;
00348               bRetval      = true;
00349             }
00350           }
00351           break;
00352 
00353           //-------------------------------------------------------------
00354           case etUint8:
00355           case etUint16:  //fall through
00356           case etUint32:  //fall through
00357           {
00358             bool bError = false;
00359             Uint uiData = toUint(&bError);
00360             if (!bError)
00361             {
00362               releaseInstances();
00363               switch(eNewDataType)
00364               {
00365                 case etUint8:
00366                   m_Data.ucData = (Uint8)uiData;
00367                 break;
00368 
00369                 case etUint16:
00370                   m_Data.usData = (Uint16)uiData;
00371                 break;
00372 
00373                 case etUint32: //fall through
00374                 default:
00375                   m_Data.ulData = (Uint32)uiData;
00376                 break;
00377               }
00378               m_eDataType  = eNewDataType;
00379               bRetval      = true;
00380             }
00381           }
00382           break;
00383 
00384           //-------------------------------------------------------------
00385           case etBool:
00386           {
00387             bool bError = false;
00388             bool bData  = toBool(&bError);
00389             if (!bError)
00390             {
00391               releaseInstances();
00392               m_eDataType  = etBool;
00393               m_Data.bData = bData;
00394               bRetval      = true;
00395             }
00396           }
00397           break;
00398 
00399           //-------------------------------------------------------------
00400           case etFloat:
00401           {
00402             bool bError = false;
00403             Float fData = toFloat(&bError);
00404             if (!bError)
00405             {
00406               releaseInstances();
00407               m_eDataType  = etFloat;
00408               m_Data.fData = fData;
00409               bRetval      = true;
00410             }
00411           }
00412           break;
00413 
00414           //-------------------------------------------------------------
00415           case etString:
00416           {
00417             TString* pstrData = new TString(toString());
00418             releaseInstances();
00419             m_eDataType     = etString;
00420             m_Data.pstrData = pstrData;
00421             bRetval         = true;
00422           }
00423           break;
00424         }
00425 
00426       } 
00427 
00428       return bRetval;
00429     }
00430 
00431     /**********************************************************************/
00434     /**********************************************************************/
00435     inline bool equals(const TZSimpleVariant& rInpar) const
00436     {
00437       bool bRetval = false;
00438 
00439       //same data type
00440       if (m_eDataType == rInpar.m_eDataType)
00441       {
00442         switch(m_eDataType)
00443         {
00444           case etEmpty:
00445             bRetval = true;
00446           break;
00447 
00448           case etInt:
00449             bRetval = (m_Data.iData == rInpar.m_Data.iData);
00450           break;
00451 
00452           case etUint8:
00453             bRetval = (m_Data.ucData == rInpar.m_Data.ucData);
00454           break;
00455 
00456           case etUint16:
00457             bRetval = (m_Data.usData == rInpar.m_Data.usData);
00458           break;
00459 
00460           case etUint32:
00461             bRetval = (m_Data.ulData == rInpar.m_Data.ulData);
00462           break;
00463 
00464           case etBool:
00465             bRetval = (m_Data.bData == rInpar.m_Data.bData);
00466           break;
00467 
00468           case etFloat:
00469             bRetval = (m_Data.fData == rInpar.m_Data.fData);
00470           break;
00471 
00472           case etString:
00473             bRetval = m_Data.pstrData->equalsStr(*rInpar.m_Data.pstrData);
00474           break;
00475         }
00476       }
00477       else
00478       {
00479         switch(m_eDataType)
00480         {
00481           case etInt:
00482             bRetval = equalsInt(rInpar.toInt());
00483           break;
00484 
00485           case etUint8:  //fall through
00486           case etUint16: //fall through
00487           case etUint32: //fall through
00488             bRetval = equalsUint(rInpar.toUint());
00489           break;
00490 
00491           case etBool:
00492             bRetval = equalsBool(rInpar.toBool());
00493           break;
00494 
00495           case etFloat:
00496             bRetval = equalsFloat(rInpar.toFloat());
00497           break;
00498 
00499           case etString:
00500             bRetval = equalsString(rInpar.toString());
00501           break;
00502         }
00503       }
00504       return bRetval;
00505     }
00506 
00507     /**********************************************************************/
00510     /**********************************************************************/
00511     inline bool equalsInt(Int iValue) const
00512     {
00513       bool bRetval = false;
00514       switch(m_eDataType)
00515       {
00516         case etEmpty:
00517         break;
00518 
00519         case etInt:
00520           bRetval = (m_Data.iData == iValue);
00521         break;
00522 
00523         case etUint8:
00524           bRetval = (iValue == (Int)m_Data.ucData);
00525         break;
00526 
00527         case etUint16:
00528           bRetval = (iValue == (Int)m_Data.usData);
00529         break;
00530 
00531         case etUint32:
00532           bRetval = (iValue == (Int32)m_Data.ulData);
00533         break;
00534 
00535         case etBool:
00536           bRetval = (iValue == (Int)m_Data.iData);
00537         break;
00538 
00539         case etFloat:
00540           bRetval = TFloat::equalsFloat(m_Data.fData, (Float)iValue);
00541         break;
00542 
00543         case etString:
00544           bRetval = m_Data.pstrData->equalsStr(TString(iValue));
00545         break;
00546       }
00547       return bRetval;
00548     }
00549 
00550     /**********************************************************************/
00553     /**********************************************************************/
00554     inline bool equalsUint(Uint uiValue) const
00555     {
00556       bool bRetval = false;
00557       switch(m_eDataType)
00558       {
00559         case etEmpty:
00560         break;
00561 
00562         case etInt:
00563           bRetval = (m_Data.iData == (Int)uiValue);
00564         break;
00565 
00566         case etUint8:
00567           bRetval = (uiValue == (Uint)m_Data.ucData);
00568         break;
00569 
00570         case etUint16:
00571           bRetval = (uiValue == (Uint)m_Data.usData);
00572         break;
00573 
00574         case etUint32:
00575           bRetval = (uiValue == (Uint)m_Data.ulData);
00576         break;
00577 
00578         case etBool:
00579           bRetval = (uiValue == (Uint)m_Data.bData);
00580         break;
00581 
00582         case etFloat:
00583           bRetval = TFloat::equalsFloat(m_Data.fData, (Float)uiValue);
00584         break;
00585 
00586         case etString:
00587           bRetval = m_Data.pstrData->equalsStr(TString(uiValue));
00588         break;
00589       }
00590       return bRetval;
00591     }
00592 
00593     /**********************************************************************/
00596     /**********************************************************************/
00597     inline bool equalsBool(bool bValue) const
00598     {
00599       bool bRetval = false;
00600       switch(m_eDataType)
00601       {
00602         case etEmpty:
00603         break;
00604 
00605         case etInt:
00606           bRetval = (bValue == (bool)m_Data.iData);
00607         break;
00608 
00609         case etUint8:
00610           bRetval = (bValue == (bool)m_Data.ucData);
00611         break;
00612 
00613         case etUint16:
00614           bRetval = (bValue == (bool)m_Data.usData);
00615         break;
00616 
00617         case etUint32:
00618           bRetval = (bValue == (bool)m_Data.ulData);
00619         break;
00620 
00621         case etBool:
00622           bRetval = (bValue == m_Data.bData);
00623         break;
00624 
00625         case etFloat:
00626           bRetval = (bValue == (bool)m_Data.fData);
00627         break;
00628 
00629         case etString:
00630           bRetval = m_Data.pstrData->equalsStr(TString(bValue));
00631         break;
00632       }
00633       return bRetval;
00634     }
00635 
00636     /**********************************************************************/
00639     /**********************************************************************/
00640     inline bool equalsFloat(const Float& rfValue) const
00641     {
00642       bool bRetval = false;
00643       switch(m_eDataType)
00644       {
00645         case etEmpty:
00646         break;
00647 
00648         case etInt:
00649           bRetval = TFloat::equalsFloat(rfValue, (Float)m_Data.iData);
00650         break;
00651 
00652         case etUint8:
00653           bRetval = TFloat::equalsFloat(rfValue, (Float)m_Data.ucData);
00654         break;
00655 
00656         case etUint16:
00657           bRetval = TFloat::equalsFloat(rfValue, (Float)m_Data.usData);
00658         break;
00659 
00660         case etUint32:
00661           bRetval = TFloat::equalsFloat(rfValue, (Float)m_Data.ulData);
00662         break;
00663 
00664         case etBool:
00665           bRetval = TFloat::equalsFloat(rfValue, (Float)m_Data.bData);
00666         break;
00667 
00668         case etFloat:
00669           bRetval = TFloat::equalsFloat(rfValue, m_Data.fData);
00670         break;
00671 
00672         case etString:
00673           bRetval = m_Data.pstrData->equalsStr(TString(rfValue));
00674         break;
00675       }
00676       return bRetval;
00677     }
00678 
00679     /**********************************************************************/
00682     /**********************************************************************/
00683     inline bool equalsString(const IString& rstrValue) const
00684     {
00685       bool bRetval = false;
00686       switch(m_eDataType)
00687       {
00688         case etEmpty:
00689           bRetval = rstrValue.isEmpty();
00690         break;
00691 
00692         case etInt:
00693           bRetval = rstrValue.equalsStr(TString(m_Data.iData));
00694         break;
00695 
00696         case etUint8:
00697           bRetval = rstrValue.equalsStr(TString((Uint)m_Data.ucData));
00698         break;
00699 
00700         case etUint16:
00701           bRetval = rstrValue.equalsStr(TString((Uint)m_Data.usData));
00702         break;
00703 
00704         case etUint32:
00705           bRetval = rstrValue.equalsStr(TString((Uint)m_Data.ulData));
00706         break;
00707 
00708         case etBool:
00709           bRetval = rstrValue.equalsStr(TString(m_Data.bData));
00710         break;
00711 
00712         case etFloat:
00713           bRetval = rstrValue.equalsStr(TString(m_Data.fData));
00714         break;
00715 
00716         case etString:
00717           bRetval = m_Data.pstrData->equalsStr(rstrValue);
00718         break;
00719       }
00720       return bRetval;
00721     }
00722 
00723     /**********************************************************************/
00726     /**********************************************************************/
00727     inline EDataType getDataType() const
00728     {
00729       return m_eDataType;
00730     }
00731 
00732     /**********************************************************************/
00735     /**********************************************************************/
00736     inline const TZSimpleVariantData& getData() const
00737     {
00738       return m_Data;
00739     }
00740 
00741     /**********************************************************************/
00744     /**********************************************************************/
00745     inline TZSimpleVariantData& getData()
00746     {
00747       return m_Data;
00748     }
00749 
00750     /**********************************************************************/
00753     /**********************************************************************/
00754     inline Int toInt(bool* pbError = NULL) const
00755     {
00756       Int iRetval = 0;
00757       switch(m_eDataType)
00758       {
00759         case etEmpty:
00760         break;
00761 
00762         case etInt:
00763           iRetval = m_Data.iData;
00764         break;
00765 
00766         case etUint8:
00767           iRetval = (Int)m_Data.ucData;
00768         break;
00769 
00770         case etUint16:
00771           iRetval = (Int)m_Data.usData;
00772         break;
00773 
00774         case etUint32:
00775           iRetval = (Int)m_Data.ulData;
00776         break;
00777 
00778         case etBool:
00779           iRetval = m_Data.bData;
00780         break;
00781 
00782         case etFloat:
00783           iRetval = TFloat(m_Data.fData).roundInt();
00784         break;
00785 
00786         case etString:
00787           iRetval = m_Data.pstrData->toInt(0, pbError);
00788         break;
00789       }
00790       return iRetval;
00791     }
00792 
00793     /**********************************************************************/
00796     /**********************************************************************/
00797     inline Int8 toInt8(bool* pbError = NULL) const
00798     {
00799       return (Int8)toInt(pbError);
00800     }
00801 
00802     /**********************************************************************/
00805     /**********************************************************************/
00806     inline Int16 toInt16(bool* pbError = NULL) const
00807     {
00808       return (Int16)toInt(pbError);
00809     }
00810 
00811     /**********************************************************************/
00814     /**********************************************************************/
00815     inline Int32 toInt32(bool* pbError = NULL) const
00816     {
00817       return (Int32)toInt(pbError);
00818     }
00819 
00820     /**********************************************************************/
00824     /**********************************************************************/
00825     inline Int toIntWithSign(bool* pbError = NULL) const
00826     {
00827       Int iRetval = 0;
00828       switch(m_eDataType)
00829       {
00830         case etUint8:
00831           iRetval = toInt8(pbError);
00832         break;
00833 
00834         case etUint16:
00835           iRetval = toInt16(pbError);
00836         break;
00837 
00838         case etUint32:
00839           iRetval = toInt32(pbError);
00840         break;
00841 
00842         default:
00843           iRetval = toInt(pbError);
00844         break;
00845       }
00846       return iRetval;
00847     }
00848 
00849     /**********************************************************************/
00852     /**********************************************************************/
00853     inline Uint toUint(bool* pbError = NULL) const
00854     {
00855       Uint uiRetval = 0;
00856       switch(m_eDataType)
00857       {
00858         case etEmpty:
00859         break;
00860 
00861         case etInt:
00862           uiRetval = (Uint)m_Data.iData;
00863         break;
00864 
00865         case etUint8:
00866           uiRetval = m_Data.ulData;
00867         break;
00868 
00869         case etUint16:
00870           uiRetval = m_Data.usData;
00871         break;
00872 
00873         case etUint32:
00874           uiRetval = m_Data.ulData;
00875         break;
00876 
00877         case etBool:
00878           uiRetval = m_Data.bData;
00879         break;
00880 
00881         case etFloat:
00882           uiRetval = (Uint)TFloat(m_Data.fData).roundInt();
00883         break;
00884 
00885         case etString:
00886           uiRetval = m_Data.pstrData->toUint(0, pbError);
00887         break;
00888       }
00889       return uiRetval;
00890     }
00891 
00892     /**********************************************************************/
00895     /**********************************************************************/
00896     inline bool toBool(bool* pbError = NULL) const
00897     {
00898       bool bRetval = false;
00899       switch(m_eDataType)
00900       {
00901         case etEmpty:
00902         break;
00903 
00904         case etInt:
00905           bRetval = (m_Data.iData != 0);
00906         break;
00907 
00908         case etUint8:
00909           bRetval = (m_Data.ucData != 0);
00910         break;
00911 
00912         case etUint16:
00913           bRetval = (m_Data.usData != 0);
00914         break;
00915 
00916         case etUint32:
00917           bRetval = (m_Data.ulData != 0);
00918         break;
00919 
00920         case etBool:
00921           bRetval = m_Data.bData;
00922         break;
00923 
00924         case etFloat:
00925           bRetval = !TFloat::isZero(m_Data.fData, FLOAT_PRECISION);
00926         break;
00927 
00928         case etString:
00929           bRetval = m_Data.pstrData->toBool(pbError);
00930         break;
00931       }
00932       return bRetval;
00933     }
00934 
00935     /**********************************************************************/
00938     /**********************************************************************/
00939     inline Float toFloat(bool* pbError = NULL) const
00940     {
00941       Float fRetval = 0;
00942       switch(m_eDataType)
00943       {
00944         case etEmpty:
00945         break;
00946 
00947         case etInt:
00948           fRetval = m_Data.iData;
00949         break;
00950 
00951         case etUint8:
00952           fRetval = m_Data.ucData;
00953         break;
00954 
00955         case etUint16:
00956           fRetval = m_Data.usData;
00957         break;
00958 
00959         case etUint32:
00960           fRetval = m_Data.ulData;
00961         break;
00962 
00963         case etBool:
00964           fRetval = m_Data.bData;
00965         break;
00966 
00967         case etFloat:
00968           fRetval = m_Data.fData;
00969         break;
00970 
00971         case etString:
00972           fRetval = m_Data.pstrData->toFloat(0, pbError);
00973         break;
00974       }
00975       return fRetval;
00976     }
00977 
00978     /**********************************************************************/
00982     /**********************************************************************/
00983     inline Float toFloatWithSign(bool* pbError = NULL) const
00984     {
00985       Float fRetval = 0;
00986       switch(m_eDataType)
00987       {
00988         case etUint8:
00989           fRetval = toInt8(pbError);
00990         break;
00991 
00992         case etUint16:
00993           fRetval = toInt16(pbError);
00994         break;
00995 
00996         case etUint32:
00997           fRetval = toInt32(pbError);
00998         break;
00999 
01000         default:
01001           fRetval = toFloat(pbError);
01002         break;
01003       }
01004       return fRetval;
01005     }
01006 
01007     /**********************************************************************/
01010     /**********************************************************************/
01011     inline TString toString() const
01012     {
01013       TString strRetval;
01014       switch(m_eDataType)
01015       {
01016         case etEmpty:
01017         break;
01018 
01019         case etInt:
01020           strRetval = m_Data.iData;
01021         break;
01022 
01023         case etUint8:
01024           strRetval = (Uint)m_Data.ucData;
01025         break;
01026 
01027         case etUint16:
01028           strRetval = (Uint)m_Data.usData;
01029         break;
01030 
01031         case etUint32:
01032           strRetval = (Uint)m_Data.ulData;
01033         break;
01034 
01035         case etBool:
01036           strRetval = m_Data.bData;
01037         break;
01038 
01039         case etFloat:
01040           strRetval = m_Data.fData;
01041         break;
01042 
01043         case etString:
01044           strRetval = *m_Data.pstrData;
01045         break;
01046       }
01047       return strRetval;
01048     }
01049 
01050     // assigns operators
01051     inline TZSimpleVariant& operator=(const TZSimpleVariant& rInpar) { assign(rInpar);          return *this; }
01052     inline TZSimpleVariant& operator=(int iValue)                    { assignInt(iValue);       return *this; }
01053     inline TZSimpleVariant& operator=(Int iValue)                    { assignInt(iValue);       return *this; }
01054     inline TZSimpleVariant& operator=(Uint8 uiValue)                 { assignUint8(uiValue);    return *this; }
01055     inline TZSimpleVariant& operator=(Uint16 uiValue)                { assignUint16(uiValue);   return *this; }
01056     inline TZSimpleVariant& operator=(Uint32 uiValue)                { assignUint32(uiValue);   return *this; }
01057     inline TZSimpleVariant& operator=(unsigned int uiValue)          { assignUint32(uiValue);   return *this; }
01058     inline TZSimpleVariant& operator=(bool bValue)                   { assignBool(bValue);      return *this; }
01059     inline TZSimpleVariant& operator=(const Float& rfValue)          { assignFloat(rfValue);    return *this; }
01060     inline TZSimpleVariant& operator=(const IString& rstrValue)      { assignString(rstrValue); return *this; }
01061 
01062 
01063     //Equals operator
01064     inline bool operator==(const TZSimpleVariant& rInpar) const { return equals(rInpar); }
01065     inline bool operator==(int iValue) const                    { return equalsInt(iValue); }
01066     inline bool operator==(Int iValue) const                    { return equalsInt(iValue); }
01067     inline bool operator==(Uint8 ucValue) const                 { return equalsUint(ucValue); }
01068     inline bool operator==(Uint16 usValue) const                { return equalsUint(usValue); }
01069     inline bool operator==(Uint32 ulValue) const                { return equalsUint(ulValue); }
01070     inline bool operator==(unsigned int uiValue) const          { return equalsUint(uiValue); }
01071     inline bool operator==(bool bValue) const                   { return equalsBool(bValue); }
01072     inline bool operator==(const Float& rfValue) const          { return equalsFloat(rfValue); }
01073     inline bool operator==(const IString& rstrValue) const      { return equalsString(rstrValue); }
01074 
01075     inline bool operator!=(const TZSimpleVariant& rInpar) const { return !equals(rInpar); }
01076     inline bool operator!=(int iValue) const                    { return !equalsInt(iValue); }
01077     inline bool operator!=(Int iValue) const                    { return !equalsInt(iValue); }
01078     inline bool operator!=(Uint8 ucValue) const                 { return !equalsUint(ucValue); }
01079     inline bool operator!=(Uint16 usValue) const                { return !equalsUint(usValue); }
01080     inline bool operator!=(Uint32 ulValue) const                { return !equalsUint(ulValue); }
01081     inline bool operator!=(unsigned int uiValue) const          { return !equalsUint(uiValue); }
01082     inline bool operator!=(bool bValue) const                   { return !equalsBool(bValue); }
01083     inline bool operator!=(const Float& rfValue) const          { return !equalsFloat(rfValue); }
01084     inline bool operator!=(const IString& rstrValue) const      { return !equalsString(rstrValue); }
01085 
01086   protected:
01087 
01088   private:
01089 
01091     TZSimpleVariantData m_Data;
01093     EDataType m_eDataType;
01094 
01095     /**********************************************************************/
01098     /**********************************************************************/
01099     inline void releaseInstances()
01100     {
01101       if (m_eDataType == etString && m_Data.pstrData != NULL)
01102       {
01103         delete m_Data.pstrData;
01104         m_Data.pstrData = NULL;
01105       }
01106     }
01107 };
01108 
01109 
01110 END_NAMESPACE_Zeus
01111 
01112 #endif
01113