src/ui/FUi_VariantImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Flora License, Version 1.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://floralicense.org/license/
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an AS IS BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 /**
  18  * @file                FUi_VariantImpl.cpp
  19  * @brief               This is the implementation file for _VariantImpl class.
  20  */
  21
  22 #include <FBaseDateTime.h>
  23 #include <FBaseString.h>
  24 #include <FBaseStringComparer.h>
  25 #include <FGrpFloatMatrix4.h>
  26 #include <FGrpRectangle.h>
  27 #include <FGrpDimension.h>
  28 #include <FGrpPoint.h>
  29 #include <FGrpColor.h>
  30 #include <FGrpFloatPoint.h>
  31 #include <FGrpFloatRectangle.h>
  32 #include <FGrpFloatDimension.h>
  33 #include <FBaseSysLog.h>
  34 #include "FUi_VariantImpl.h"
  35
  36 using namespace Tizen::Base;
  37 using namespace Tizen::Ui;
  38 using namespace Tizen::Graphics;
  39
  40 namespace Tizen { namespace Ui
  41 {
  42
  43 _VariantImpl::_VariantImpl(void)
  44         : __refCount(1)
  45         , __type(VARIANT_TYPE_NONE)
  46 {
  47         __data.valueLongLong = 0;
  48 }
  49
  50 _VariantImpl::~_VariantImpl(void)
  51 {
  52         Clear();
  53 }
  54
  55 void
  56 _VariantImpl::AddRef(void)
  57 {
  58         __refCount++;
  59 }
  60
  61 void
  62 _VariantImpl::Release(void)
  63 {
  64         if (__refCount >= 1)
  65         {
  66                 __refCount--;
  67                 if (__refCount == 0)
  68                 {
  69                         delete this;
  70                 }
  71         }
  72 }
  73
  74 void
  75 _VariantImpl::Clear(void)
  76 {
  77         if (unlikely(__type == VARIANT_TYPE_NONE))
  78         {
  79                 __data.valueDouble = 0;
  80                 return;
  81         }
  82
  83         switch (__type)
  84         {
  85         case VARIANT_TYPE_NONE:
  86                 return;
  87
  88         case VARIANT_TYPE_INT:
  89                 __data.valueInt = 0;
  90                 break;
  91
  92         case VARIANT_TYPE_UINT:
  93                 __data.valueUInt = 0;
  94                 break;
  95
  96         case VARIANT_TYPE_BOOL:
  97                 __data.valueBool = false;
  98                 break;
  99
 100         case VARIANT_TYPE_FLOAT:
 101                 __data.valueFloat = 0;
 102                 break;
 103
 104         case VARIANT_TYPE_DOUBLE:
 105                 __data.valueDouble = 0;
 106                 break;
 107
 108         case VARIANT_TYPE_LONG:
 109                 __data.valueLong = 0;
 110                 break;
 111
 112         case VARIANT_TYPE_ULONG:
 113                 __data.valueULong = 0;
 114                 break;
 115
 116         case VARIANT_TYPE_LONGLONG:
 117                 __data.valueLongLong = 0;
 118                 break;
 119
 120         case VARIANT_TYPE_ULONGLONG:
 121                 __data.valueULongLong = 0;
 122                 break;
 123
 124         case VARIANT_TYPE_STRING:
 125         {
 126                 delete __data.pString;
 127                 __data.pString = null;
 128                 break;
 129         }
 130
 131         case VARIANT_TYPE_DATETIME:
 132         {
 133                 delete __data.pDateTime;
 134                 __data.pDateTime = null;
 135                 break;
 136         }
 137
 138         case VARIANT_TYPE_COLOR:
 139         {
 140                 delete __data.pColor;
 141                 __data.pColor = null;
 142                 break;
 143         }
 144
 145         case VARIANT_TYPE_POINT:
 146         {
 147                 delete __data.pPoint;
 148                 __data.pPoint = null;
 149                 break;
 150         }
 151
 152         case VARIANT_TYPE_FLOAT_POINT:
 153         {
 154                 delete __data.pFloatPoint;
 155                 __data.pFloatPoint = null;
 156                 break;
 157         }
 158
 159         case VARIANT_TYPE_RECTANGLE:
 160         {
 161                 delete __data.pRect;
 162                 __data.pRect = null;
 163                 break;
 164         }
 165
 166         case VARIANT_TYPE_FLOAT_RECTANGLE:
 167         {
 168                 delete __data.pRectf;
 169                 __data.pRectf = null;
 170                 break;
 171         }
 172
 173         case VARIANT_TYPE_DIMENSION:
 174         {
 175                 delete __data.pDimension;
 176                 __data.pDimension = null;
 177                 break;
 178         }
 179
 180         case VARIANT_TYPE_FLOAT_DIMENSION:
 181         {
 182                 delete __data.pFloatDimension;
 183                 __data.pFloatDimension = null;
 184                 break;
 185         }
 186
 187         case VARIANT_TYPE_FLOAT_MATRIX4:
 188         {
 189                 delete __data.pFloatMatrix4;
 190                 __data.pFloatMatrix4 = null;
 191                 break;
 192         }
 193
 194         default:
 195                 break;
 196         }
 197
 198         __type = VARIANT_TYPE_NONE;
 199 }
 200
 201 void
 202 _VariantImpl::Copy(const Variant& rhs)
 203 {
 204         const _VariantImpl* pImpl = rhs.GetVariantImpl();
 205         __type = pImpl->__type;
 206
 207         switch (pImpl->__type)
 208         {
 209         case VARIANT_TYPE_NONE:
 210                 break;
 211
 212         case VARIANT_TYPE_INT:
 213                 __data.valueInt = pImpl->__data.valueInt;
 214                 break;
 215
 216         case VARIANT_TYPE_UINT:
 217                 __data.valueUInt = pImpl->__data.valueUInt;
 218                 break;
 219
 220         case VARIANT_TYPE_BOOL:
 221                 __data.valueBool = pImpl->__data.valueBool;
 222                 break;
 223
 224         case VARIANT_TYPE_FLOAT:
 225                 __data.valueFloat = pImpl->__data.valueFloat;
 226                 break;
 227
 228         case VARIANT_TYPE_DOUBLE:
 229                 __data.valueDouble = pImpl->__data.valueDouble;
 230                 break;
 231
 232         case VARIANT_TYPE_LONG:
 233                 __data.valueLong = pImpl->__data.valueLong;
 234                 break;
 235
 236         case VARIANT_TYPE_ULONG:
 237                 __data.valueULong = pImpl->__data.valueULong;
 238                 break;
 239
 240         case VARIANT_TYPE_LONGLONG:
 241                 __data.valueLongLong = pImpl->__data.valueLongLong;
 242                 break;
 243
 244         case VARIANT_TYPE_ULONGLONG:
 245                 __data.valueULongLong = pImpl->__data.valueULongLong;
 246                 break;
 247
 248         case VARIANT_TYPE_STRING:
 249                 __data.pString = new (std::nothrow) String(*pImpl->__data.pString);
 250                 break;
 251
 252         case VARIANT_TYPE_DATETIME:
 253                 __data.pDateTime = new (std::nothrow) DateTime(*pImpl->__data.pDateTime);
 254                 break;
 255
 256         case VARIANT_TYPE_COLOR:
 257                 __data.pColor = new (std::nothrow) Color(*pImpl->__data.pColor);
 258                 break;
 259
 260         case VARIANT_TYPE_POINT:
 261                 __data.pPoint = new (std::nothrow) Point(*pImpl->__data.pPoint);
 262                 break;
 263
 264         case VARIANT_TYPE_FLOAT_POINT:
 265                 __data.pFloatPoint = new (std::nothrow) FloatPoint(*pImpl->__data.pFloatPoint);
 266                 break;
 267
 268         case VARIANT_TYPE_RECTANGLE:
 269                 __data.pRect = new (std::nothrow) Rectangle(*pImpl->__data.pRect);
 270                 break;
 271
 272         case VARIANT_TYPE_FLOAT_RECTANGLE:
 273                 __data.pRectf = new (std::nothrow) FloatRectangle(*pImpl->__data.pRectf);
 274                 break;
 275
 276         case VARIANT_TYPE_DIMENSION:
 277                 __data.pDimension = new (std::nothrow) Dimension(*pImpl->__data.pDimension);
 278                 break;
 279
 280         case VARIANT_TYPE_FLOAT_DIMENSION:
 281                 __data.pFloatDimension = new (std::nothrow) FloatDimension(*pImpl->__data.pFloatDimension);
 282                 break;
 283
 284         case VARIANT_TYPE_FLOAT_MATRIX4:
 285                 __data.pFloatMatrix4 = new (std::nothrow) FloatMatrix4(*pImpl->__data.pFloatMatrix4);
 286                 break;
 287
 288         default:
 289                 break;
 290         }
 291 }
 292
 293 void
 294 _VariantImpl::SetVariantType(VariantType type)
 295 {
 296         if (__type != type)
 297         {
 298                 __type = type;
 299         }
 300 }
 301
 302 bool
 303 _VariantImpl::IsSameType(VariantType type) const
 304 {
 305         return(__type == type);
 306 }
 307
 308 } } // Tizen::Ui