src/ui/FUi_VariantImpl.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.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://www.apache.org/licenses/LICENSE-2.0/
  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 <FGrpFloatPoint3.h>
  34 #include <FGrpFloatVector4.h>
  35 #include <FBaseSysLog.h>
  36 #include "FUi_VariantImpl.h"
  37
  38 using namespace Tizen::Base;
  39 using namespace Tizen::Ui;
  40 using namespace Tizen::Graphics;
  41
  42 namespace Tizen { namespace Ui
  43 {
  44
  45 _VariantImpl::_VariantImpl(void)
  46         : __refCount(1)
  47         , __type(VARIANT_TYPE_NONE)
  48 {
  49         __data.valueLongLong = 0;
  50 }
  51
  52 _VariantImpl::~_VariantImpl(void)
  53 {
  54         Clear();
  55 }
  56
  57 void
  58 _VariantImpl::AddRef(void)
  59 {
  60         __refCount++;
  61 }
  62
  63 void
  64 _VariantImpl::Release(void)
  65 {
  66         if (__refCount >= 1)
  67         {
  68                 __refCount--;
  69                 if (__refCount == 0)
  70                 {
  71                         delete this;
  72                 }
  73         }
  74 }
  75
  76 void
  77 _VariantImpl::Clear(void)
  78 {
  79         if (unlikely(__type == VARIANT_TYPE_NONE))
  80         {
  81                 __data.valueDouble = 0;
  82                 return;
  83         }
  84
  85         switch (__type)
  86         {
  87         case VARIANT_TYPE_NONE:
  88                 return;
  89
  90         case VARIANT_TYPE_INT:
  91                 __data.valueInt = 0;
  92                 break;
  93
  94         case VARIANT_TYPE_UINT:
  95                 __data.valueUInt = 0;
  96                 break;
  97
  98         case VARIANT_TYPE_BOOL:
  99                 __data.valueBool = false;
 100                 break;
 101
 102         case VARIANT_TYPE_FLOAT:
 103                 __data.valueFloat = 0;
 104                 break;
 105
 106         case VARIANT_TYPE_DOUBLE:
 107                 __data.valueDouble = 0;
 108                 break;
 109
 110         case VARIANT_TYPE_LONG:
 111                 __data.valueLong = 0;
 112                 break;
 113
 114         case VARIANT_TYPE_ULONG:
 115                 __data.valueULong = 0;
 116                 break;
 117
 118         case VARIANT_TYPE_LONGLONG:
 119                 __data.valueLongLong = 0;
 120                 break;
 121
 122         case VARIANT_TYPE_ULONGLONG:
 123                 __data.valueULongLong = 0;
 124                 break;
 125
 126         case VARIANT_TYPE_STRING:
 127         {
 128                 delete __data.pString;
 129                 __data.pString = null;
 130                 break;
 131         }
 132
 133         case VARIANT_TYPE_DATETIME:
 134         {
 135                 delete __data.pDateTime;
 136                 __data.pDateTime = null;
 137                 break;
 138         }
 139
 140         case VARIANT_TYPE_COLOR:
 141         {
 142                 delete __data.pColor;
 143                 __data.pColor = null;
 144                 break;
 145         }
 146
 147         case VARIANT_TYPE_POINT:
 148         {
 149                 delete __data.pPoint;
 150                 __data.pPoint = null;
 151                 break;
 152         }
 153
 154         case VARIANT_TYPE_FLOAT_POINT:
 155         {
 156                 delete __data.pFloatPoint;
 157                 __data.pFloatPoint = null;
 158                 break;
 159         }
 160
 161         case VARIANT_TYPE_RECTANGLE:
 162         {
 163                 delete __data.pRect;
 164                 __data.pRect = null;
 165                 break;
 166         }
 167
 168         case VARIANT_TYPE_FLOAT_RECTANGLE:
 169         {
 170                 delete __data.pRectf;
 171                 __data.pRectf = null;
 172                 break;
 173         }
 174
 175         case VARIANT_TYPE_DIMENSION:
 176         {
 177                 delete __data.pDimension;
 178                 __data.pDimension = null;
 179                 break;
 180         }
 181
 182         case VARIANT_TYPE_FLOAT_DIMENSION:
 183         {
 184                 delete __data.pFloatDimension;
 185                 __data.pFloatDimension = null;
 186                 break;
 187         }
 188
 189         case VARIANT_TYPE_FLOAT_MATRIX4:
 190         {
 191                 delete __data.pFloatMatrix4;
 192                 __data.pFloatMatrix4 = null;
 193                 break;
 194         }
 195
 196         case VARIANT_TYPE_FLOAT_POINT3:
 197         {
 198                 delete __data.pFloatPoint3;
 199                 __data.pFloatPoint3 = null;
 200                 break;
 201         }
 202
 203         case VARIANT_TYPE_FLOAT_VECTOR4:
 204         {
 205                 delete __data.pFloatVector4;
 206                 __data.pFloatVector4 = null;
 207                 break;
 208         }
 209
 210         default:
 211                 break;
 212         }
 213
 214         __type = VARIANT_TYPE_NONE;
 215 }
 216
 217 void
 218 _VariantImpl::Copy(const Variant& rhs)
 219 {
 220         const _VariantImpl* pImpl = rhs.GetVariantImpl();
 221         __type = pImpl->__type;
 222
 223         switch (pImpl->__type)
 224         {
 225         case VARIANT_TYPE_NONE:
 226                 break;
 227
 228         case VARIANT_TYPE_INT:
 229                 __data.valueInt = pImpl->__data.valueInt;
 230                 break;
 231
 232         case VARIANT_TYPE_UINT:
 233                 __data.valueUInt = pImpl->__data.valueUInt;
 234                 break;
 235
 236         case VARIANT_TYPE_BOOL:
 237                 __data.valueBool = pImpl->__data.valueBool;
 238                 break;
 239
 240         case VARIANT_TYPE_FLOAT:
 241                 __data.valueFloat = pImpl->__data.valueFloat;
 242                 break;
 243
 244         case VARIANT_TYPE_DOUBLE:
 245                 __data.valueDouble = pImpl->__data.valueDouble;
 246                 break;
 247
 248         case VARIANT_TYPE_LONG:
 249                 __data.valueLong = pImpl->__data.valueLong;
 250                 break;
 251
 252         case VARIANT_TYPE_ULONG:
 253                 __data.valueULong = pImpl->__data.valueULong;
 254                 break;
 255
 256         case VARIANT_TYPE_LONGLONG:
 257                 __data.valueLongLong = pImpl->__data.valueLongLong;
 258                 break;
 259
 260         case VARIANT_TYPE_ULONGLONG:
 261                 __data.valueULongLong = pImpl->__data.valueULongLong;
 262                 break;
 263
 264         case VARIANT_TYPE_STRING:
 265                 __data.pString = new (std::nothrow) String(*pImpl->__data.pString);
 266                 break;
 267
 268         case VARIANT_TYPE_DATETIME:
 269                 __data.pDateTime = new (std::nothrow) DateTime(*pImpl->__data.pDateTime);
 270                 break;
 271
 272         case VARIANT_TYPE_COLOR:
 273                 __data.pColor = new (std::nothrow) Color(*pImpl->__data.pColor);
 274                 break;
 275
 276         case VARIANT_TYPE_POINT:
 277                 __data.pPoint = new (std::nothrow) Point(*pImpl->__data.pPoint);
 278                 break;
 279
 280         case VARIANT_TYPE_FLOAT_POINT:
 281                 __data.pFloatPoint = new (std::nothrow) FloatPoint(*pImpl->__data.pFloatPoint);
 282                 break;
 283
 284         case VARIANT_TYPE_RECTANGLE:
 285                 __data.pRect = new (std::nothrow) Rectangle(*pImpl->__data.pRect);
 286                 break;
 287
 288         case VARIANT_TYPE_FLOAT_RECTANGLE:
 289                 __data.pRectf = new (std::nothrow) FloatRectangle(*pImpl->__data.pRectf);
 290                 break;
 291
 292         case VARIANT_TYPE_DIMENSION:
 293                 __data.pDimension = new (std::nothrow) Dimension(*pImpl->__data.pDimension);
 294                 break;
 295
 296         case VARIANT_TYPE_FLOAT_DIMENSION:
 297                 __data.pFloatDimension = new (std::nothrow) FloatDimension(*pImpl->__data.pFloatDimension);
 298                 break;
 299
 300         case VARIANT_TYPE_FLOAT_MATRIX4:
 301                 __data.pFloatMatrix4 = new (std::nothrow) FloatMatrix4(*pImpl->__data.pFloatMatrix4);
 302                 break;
 303
 304         case VARIANT_TYPE_FLOAT_POINT3:
 305                 __data.pFloatPoint3 = new (std::nothrow) FloatPoint3(*pImpl->__data.pFloatPoint3);
 306                 break;
 307
 308         case VARIANT_TYPE_FLOAT_VECTOR4:
 309                 __data.pFloatVector4 = new (std::nothrow) FloatVector4(*pImpl->__data.pFloatVector4);
 310                 break;
 311
 312         default:
 313                 break;
 314         }
 315 }
 316
 317 void
 318 _VariantImpl::SetVariantType(VariantType type)
 319 {
 320         if (__type != type)
 321         {
 322                 __type = type;
 323         }
 324 }
 325
 326 bool
 327 _VariantImpl::IsSameType(VariantType type) const
 328 {
 329         return(__type == type);
 330 }
 331
 332 } } // Tizen::Ui