src/ui/FUiVariant.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                FUiVariant.cpp
  19  * @brief               This is the implementation file for Variant class.
  20  */
  21
  22 // Includes
  23 #include <FUiVariant.h>
  24 #include <FBaseErrors.h>
  25 #include <FBaseDateTime.h>
  26 #include <FBaseString.h>
  27 #include <FBaseStringComparer.h>
  28 #include <FGrpFloatMatrix4.h>
  29 #include <FGrpRectangle.h>
  30 #include <FGrpDimension.h>
  31 #include <FGrpPoint.h>
  32 #include <FGrpColor.h>
  33 #include <FGrpFloatPoint.h>
  34 #include <FGrpFloatRectangle.h>
  35 #include <FGrpFloatDimension.h>
  36 #include <FBaseSysLog.h>
  37 #include "FUi_VariantImpl.h"
  38
  39 using namespace Tizen::Base;
  40 using namespace Tizen::Graphics;
  41
  42 namespace Tizen { namespace Ui
  43 {
  44
  45 const Variant Variant::NULL_VARIANT;
  46
  47 Variant::Variant(void)
  48         : __pVariantImpl(null)
  49 {
  50         __pVariantImpl = new (std::nothrow) _VariantImpl;
  51         if (__pVariantImpl == null)
  52         {
  53                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
  54         }
  55 }
  56
  57 Variant::~Variant(void)
  58 {
  59         if (__pVariantImpl)
  60         {
  61                 __pVariantImpl->Release();
  62         }
  63
  64         __pVariantImpl = null;
  65 }
  66
  67 Variant::Variant(const Variant& value)
  68         : __pVariantImpl(null)
  69 {
  70         SysAssertf(value.__pVariantImpl, "No data in rhs for copy ctor");
  71         __pVariantImpl = value.__pVariantImpl;
  72         __pVariantImpl->AddRef();
  73 }
  74
  75 Variant::Variant(int value)
  76         : __pVariantImpl(null)
  77 {
  78         __pVariantImpl = new (std::nothrow) _VariantImpl;
  79         if (__pVariantImpl == null)
  80         {
  81                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
  82         }
  83         else
  84         {
  85                 __pVariantImpl->__type = VARIANT_TYPE_INT;
  86                 __pVariantImpl->__data.valueInt = 0;
  87                 __pVariantImpl->__data.valueInt = value;
  88         }
  89 }
  90
  91 Variant::Variant(unsigned int value)
  92         : __pVariantImpl(null)
  93 {
  94         __pVariantImpl = new (std::nothrow) _VariantImpl;
  95         if (__pVariantImpl == null)
  96         {
  97                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
  98         }
  99         else
 100         {
 101                 __pVariantImpl->__type = VARIANT_TYPE_UINT;
 102                 __pVariantImpl->__data.valueUInt = 0;
 103                 __pVariantImpl->__data.valueUInt = value;
 104         }
 105 }
 106
 107 Variant::Variant(bool value)
 108         : __pVariantImpl(null)
 109 {
 110         __pVariantImpl = new (std::nothrow) _VariantImpl;
 111         if (__pVariantImpl == null)
 112         {
 113                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 114         }
 115         else
 116         {
 117                 __pVariantImpl->__type = VARIANT_TYPE_BOOL;
 118                 __pVariantImpl->__data.valueBool = true;
 119                 __pVariantImpl->__data.valueBool = value;
 120         }
 121 }
 122
 123 Variant::Variant(float value)
 124         : __pVariantImpl(null)
 125 {
 126         __pVariantImpl = new (std::nothrow) _VariantImpl;
 127         if (__pVariantImpl == null)
 128         {
 129                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 130         }
 131         else
 132         {
 133                 __pVariantImpl->__type = VARIANT_TYPE_FLOAT;
 134                 __pVariantImpl->__data.valueFloat = 0;
 135                 __pVariantImpl->__data.valueFloat = value;
 136         }
 137 }
 138
 139 Variant::Variant(double value)
 140         : __pVariantImpl(null)
 141 {
 142         __pVariantImpl = new (std::nothrow) _VariantImpl;
 143         if (__pVariantImpl == null)
 144         {
 145                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 146         }
 147         else
 148         {
 149                 __pVariantImpl->__type = VARIANT_TYPE_DOUBLE;
 150                 __pVariantImpl->__data.valueDouble = 0;
 151                 __pVariantImpl->__data.valueDouble = value;
 152         }
 153 }
 154
 155 Variant::Variant(long value)
 156         : __pVariantImpl(null)
 157 {
 158         __pVariantImpl = new (std::nothrow) _VariantImpl;
 159         if (__pVariantImpl == null)
 160         {
 161                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 162         }
 163         else
 164         {
 165                 __pVariantImpl->__type = VARIANT_TYPE_LONG;
 166                 __pVariantImpl->__data.valueLong = 0;
 167                 __pVariantImpl->__data.valueLong = value;
 168         }
 169 }
 170
 171 Variant::Variant(unsigned long value)
 172         : __pVariantImpl(null)
 173 {
 174         __pVariantImpl = new (std::nothrow) _VariantImpl;
 175         if (__pVariantImpl == null)
 176         {
 177                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 178         }
 179         else
 180         {
 181                 __pVariantImpl->__type = VARIANT_TYPE_ULONG;
 182                 __pVariantImpl->__data.valueULong = 0;
 183                 __pVariantImpl->__data.valueULong = value;
 184         }
 185 }
 186
 187 Variant::Variant(long long value)
 188         : __pVariantImpl(null)
 189 {
 190         __pVariantImpl = new (std::nothrow) _VariantImpl;
 191         if (__pVariantImpl == null)
 192         {
 193                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 194         }
 195         else
 196         {
 197                 __pVariantImpl->__type = VARIANT_TYPE_LONGLONG;
 198                 __pVariantImpl->__data.valueLongLong = 0;
 199                 __pVariantImpl->__data.valueLongLong = value;
 200         }
 201 }
 202
 203 Variant::Variant(unsigned long long value)
 204         : __pVariantImpl(null)
 205 {
 206         __pVariantImpl = new (std::nothrow) _VariantImpl;
 207         if (__pVariantImpl == null)
 208         {
 209                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 210         }
 211         else
 212         {
 213                 __pVariantImpl->__type = VARIANT_TYPE_ULONGLONG;
 214                 __pVariantImpl->__data.valueULongLong = 0;
 215                 __pVariantImpl->__data.valueULongLong = value;
 216         }
 217 }
 218
 219 Variant::Variant(const char* pValue)
 220         : __pVariantImpl(null)
 221 {
 222         __pVariantImpl = new (std::nothrow) _VariantImpl;
 223         if (__pVariantImpl == null)
 224         {
 225                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 226         }
 227         else
 228         {
 229                 __pVariantImpl->__type = VARIANT_TYPE_STRING;
 230                 __pVariantImpl->__data.pString = null;
 231                 __pVariantImpl->__data.pString = new (std::nothrow) String(pValue);
 232         }
 233 }
 234
 235 Variant::Variant(const wchar_t* pValue)
 236         : __pVariantImpl(null)
 237 {
 238         __pVariantImpl = new (std::nothrow) _VariantImpl;
 239         if (__pVariantImpl == null)
 240         {
 241                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 242         }
 243         else
 244         {
 245                 __pVariantImpl->__type = VARIANT_TYPE_STRING;
 246                 __pVariantImpl->__data.pString = null;
 247                 __pVariantImpl->__data.pString = new (std::nothrow) String(pValue);
 248         }
 249 }
 250
 251 Variant::Variant(const String& value)
 252         : __pVariantImpl(null)
 253 {
 254         __pVariantImpl = new (std::nothrow) _VariantImpl;
 255         if (__pVariantImpl == null)
 256         {
 257                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 258         }
 259         else
 260         {
 261                 __pVariantImpl->__type = VARIANT_TYPE_STRING;
 262                 __pVariantImpl->__data.pString = null;
 263                 __pVariantImpl->__data.pString = new (std::nothrow) String(value);
 264         }
 265 }
 266
 267 Variant::Variant(const DateTime& value)
 268         : __pVariantImpl(null)
 269 {
 270         __pVariantImpl = new (std::nothrow) _VariantImpl;
 271         if (__pVariantImpl == null)
 272         {
 273                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 274         }
 275         else
 276         {
 277                 __pVariantImpl->__type = VARIANT_TYPE_DATETIME;
 278                 __pVariantImpl->__data.pDateTime = null;
 279                 __pVariantImpl->__data.pDateTime = new (std::nothrow) DateTime(value);
 280         }
 281 }
 282
 283 Variant::Variant(const Color& value)
 284         : __pVariantImpl(null)
 285 {
 286         __pVariantImpl = new (std::nothrow) _VariantImpl;
 287         if (__pVariantImpl == null)
 288         {
 289                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 290         }
 291         else
 292         {
 293                 __pVariantImpl->__type = VARIANT_TYPE_COLOR;
 294                 __pVariantImpl->__data.pColor = null;
 295                 __pVariantImpl->__data.pColor = new (std::nothrow) Color(value);
 296         }
 297 }
 298
 299 Variant::Variant(const Point& value)
 300         : __pVariantImpl(null)
 301 {
 302         __pVariantImpl = new (std::nothrow) _VariantImpl;
 303         if (__pVariantImpl == null)
 304         {
 305                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 306         }
 307         else
 308         {
 309                 __pVariantImpl->__type = VARIANT_TYPE_POINT;
 310                 __pVariantImpl->__data.pPoint = null;
 311                 __pVariantImpl->__data.pPoint = new (std::nothrow) Point(value);
 312         }
 313 }
 314
 315 Variant::Variant(const FloatPoint& value)
 316         : __pVariantImpl(null)
 317 {
 318         __pVariantImpl = new (std::nothrow) _VariantImpl;
 319         if (__pVariantImpl == null)
 320         {
 321                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 322         }
 323         else
 324         {
 325                 __pVariantImpl->__type = VARIANT_TYPE_FLOAT_POINT;
 326                 __pVariantImpl->__data.pFloatPoint = null;
 327                 __pVariantImpl->__data.pFloatPoint = new (std::nothrow) FloatPoint(value);
 328         }
 329 }
 330
 331 Variant::Variant(const Rectangle& value)
 332         : __pVariantImpl(null)
 333 {
 334         __pVariantImpl = new (std::nothrow) _VariantImpl;
 335         if (__pVariantImpl == null)
 336         {
 337                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 338         }
 339         else
 340         {
 341                 __pVariantImpl->__type = VARIANT_TYPE_RECTANGLE;
 342                 __pVariantImpl->__data.pRect = null;
 343                 __pVariantImpl->__data.pRect = new (std::nothrow) Rectangle(value);
 344         }
 345 }
 346
 347 Variant::Variant(const FloatRectangle& value)
 348         : __pVariantImpl(null)
 349 {
 350         __pVariantImpl = new (std::nothrow) _VariantImpl;
 351         if (__pVariantImpl == null)
 352         {
 353                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 354         }
 355         else
 356         {
 357                 __pVariantImpl->__type = VARIANT_TYPE_FLOAT_RECTANGLE;
 358                 __pVariantImpl->__data.pRectf = null;
 359                 __pVariantImpl->__data.pRectf = new (std::nothrow) FloatRectangle(value);
 360         }
 361 }
 362
 363 Variant::Variant(const Dimension& value)
 364         : __pVariantImpl(null)
 365 {
 366         __pVariantImpl = new (std::nothrow) _VariantImpl;
 367         if (__pVariantImpl == null)
 368         {
 369                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 370         }
 371         else
 372         {
 373                 __pVariantImpl->__type = VARIANT_TYPE_DIMENSION;
 374                 __pVariantImpl->__data.pDimension = null;
 375                 __pVariantImpl->__data.pDimension = new (std::nothrow) Dimension(value);
 376         }
 377 }
 378
 379 Variant::Variant(const FloatDimension& value)
 380         : __pVariantImpl(null)
 381 {
 382         __pVariantImpl = new (std::nothrow) _VariantImpl;
 383         if (__pVariantImpl == null)
 384         {
 385                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 386         }
 387         else
 388         {
 389                 __pVariantImpl->__type = VARIANT_TYPE_FLOAT_DIMENSION;
 390                 __pVariantImpl->__data.pFloatDimension = null;
 391                 __pVariantImpl->__data.pFloatDimension = new (std::nothrow) FloatDimension(value);
 392         }
 393 }
 394
 395 Variant::Variant(const FloatMatrix4& value)
 396         : __pVariantImpl(null)
 397 {
 398         __pVariantImpl = new (std::nothrow) _VariantImpl;
 399         if (__pVariantImpl == null)
 400         {
 401                 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
 402         }
 403         else
 404         {
 405                 __pVariantImpl->__type = VARIANT_TYPE_FLOAT_MATRIX4;
 406                 __pVariantImpl->__data.pFloatMatrix4 = null;
 407                 __pVariantImpl->__data.pFloatMatrix4 = new (std::nothrow) FloatMatrix4(value);
 408         }
 409 }
 410
 411 // Assignment Operators
 412 Variant&
 413 Variant::operator =(const Variant& rhs)
 414 {
 415         if (&rhs != this)
 416         {
 417                 if (__pVariantImpl && rhs.__pVariantImpl && __pVariantImpl != rhs.__pVariantImpl)
 418                 {
 419                         __pVariantImpl->Release();
 420                         __pVariantImpl = rhs.__pVariantImpl;
 421                         __pVariantImpl->AddRef();
 422                 }
 423         }
 424         return (*this);
 425 }
 426
 427 #define CREATE_VARIANT_IMPL(type, member, value) \
 428         do { \
 429                 if (!__pVariantImpl || __pVariantImpl->__type != type) \
 430                 { \
 431                         _VariantImpl* pImpl = new (std::nothrow) _VariantImpl; \
 432                         if (likely(pImpl)) \
 433                         { \
 434                                 pImpl->__type = type; \
 435                                 pImpl->__data.member = value; \
 436                                 delete __pVariantImpl; \
 437                                 __pVariantImpl = pImpl; \
 438                         } \
 439                 } \
 440                 else \
 441                 { \
 442                         /* __pVariantImpl != null && __pVariantImpl->__type == type */ \
 443                         __pVariantImpl->__data.member = value; \
 444                 } \
 445         } while (0);
 446
 447 Variant&
 448 Variant::operator =(int rhs)
 449 {
 450         CREATE_VARIANT_IMPL(VARIANT_TYPE_INT, valueInt, rhs);
 451
 452         return (*this);
 453 }
 454
 455 Variant&
 456 Variant::operator =(unsigned int rhs)
 457 {
 458         CREATE_VARIANT_IMPL(VARIANT_TYPE_UINT, valueUInt, rhs);
 459
 460         return (*this);
 461 }
 462
 463 Variant&
 464 Variant::operator =(bool rhs)
 465 {
 466         CREATE_VARIANT_IMPL(VARIANT_TYPE_BOOL, valueBool, rhs);
 467
 468         return (*this);
 469 }
 470
 471 Variant&
 472 Variant::operator =(float rhs)
 473 {
 474         CREATE_VARIANT_IMPL(VARIANT_TYPE_FLOAT, valueFloat, rhs);
 475
 476         return (*this);
 477 }
 478
 479 Variant&
 480 Variant::operator =(double rhs)
 481 {
 482         CREATE_VARIANT_IMPL(VARIANT_TYPE_DOUBLE, valueDouble, rhs);
 483
 484         return (*this);
 485 }
 486
 487 Variant&
 488 Variant::operator =(long rhs)
 489 {
 490         CREATE_VARIANT_IMPL(VARIANT_TYPE_LONG, valueLong, rhs);
 491
 492         return (*this);
 493 }
 494
 495 Variant&
 496 Variant::operator =(unsigned long rhs)
 497 {
 498         CREATE_VARIANT_IMPL(VARIANT_TYPE_ULONG, valueULong, rhs);
 499
 500         return (*this);
 501 }
 502
 503 Variant&
 504 Variant::operator =(long long rhs)
 505 {
 506         CREATE_VARIANT_IMPL(VARIANT_TYPE_LONGLONG, valueLongLong, rhs);
 507
 508         return (*this);
 509 }
 510
 511 Variant&
 512 Variant::operator =(unsigned long long rhs)
 513 {
 514         CREATE_VARIANT_IMPL(VARIANT_TYPE_ULONGLONG, valueLongLong, rhs);
 515
 516         return (*this);
 517 }
 518
 519 Variant&
 520 Variant::operator =(const char* pRhs)
 521 {
 522         String* pString = new (std::nothrow) String(pRhs);
 523         CREATE_VARIANT_IMPL(VARIANT_TYPE_STRING, pString, pString);
 524
 525         return (*this);
 526 }
 527
 528 Variant&
 529 Variant::operator =(const wchar_t* pRhs)
 530 {
 531         String* pString = new (std::nothrow) String(pRhs);
 532         CREATE_VARIANT_IMPL(VARIANT_TYPE_STRING, pString, pString);
 533
 534         return (*this);
 535 }
 536
 537 Variant&
 538 Variant::operator =(const String& rhs)
 539 {
 540         String* pString = new (std::nothrow) String(rhs);
 541         CREATE_VARIANT_IMPL(VARIANT_TYPE_STRING, pString, pString);
 542
 543         return (*this);
 544 }
 545
 546 Variant&
 547 Variant::operator =(const DateTime& rhs)
 548 {
 549         DateTime* pDateTime = new (std::nothrow) DateTime(rhs);
 550         CREATE_VARIANT_IMPL(VARIANT_TYPE_DATETIME, pDateTime, pDateTime);
 551
 552         return (*this);
 553 }
 554
 555 Variant&
 556 Variant::operator =(const Color& rhs)
 557 {
 558         Color* pColor = new (std::nothrow) Color(rhs);
 559         CREATE_VARIANT_IMPL(VARIANT_TYPE_COLOR, pColor, pColor);
 560
 561         return (*this);
 562 }
 563
 564 Variant&
 565 Variant::operator =(const Point& rhs)
 566 {
 567         Point* pPoint = new (std::nothrow) Point(rhs);
 568         CREATE_VARIANT_IMPL(VARIANT_TYPE_POINT, pPoint, pPoint);
 569
 570         return (*this);
 571 }
 572
 573 Variant&
 574 Variant::operator =(const FloatPoint& rhs)
 575 {
 576
 577         FloatPoint* pFloatPoint = new (std::nothrow) FloatPoint(rhs);
 578         CREATE_VARIANT_IMPL(VARIANT_TYPE_FLOAT_POINT, pFloatPoint, pFloatPoint);
 579
 580         return (*this);
 581 }
 582
 583 Variant&
 584 Variant::operator =(const Rectangle& rhs)
 585 {
 586         Rectangle* pRectangle = new (std::nothrow) Rectangle(rhs);
 587         CREATE_VARIANT_IMPL(VARIANT_TYPE_RECTANGLE, pRect, pRectangle);
 588
 589         return (*this);
 590 }
 591
 592 Variant&
 593 Variant::operator =(const FloatRectangle& rhs)
 594 {
 595         FloatRectangle* pFloatRectangle = new (std::nothrow) FloatRectangle(rhs);
 596         CREATE_VARIANT_IMPL(VARIANT_TYPE_FLOAT_RECTANGLE, pRectf, pFloatRectangle);
 597
 598         return (*this);
 599 }
 600
 601 Variant&
 602 Variant::operator =(const Dimension& rhs)
 603 {
 604
 605         Dimension* pDimension = new (std::nothrow) Dimension(rhs);
 606         CREATE_VARIANT_IMPL(VARIANT_TYPE_DIMENSION, pDimension, pDimension);
 607
 608         return (*this);
 609 }
 610
 611 Variant&
 612 Variant::operator =(const FloatDimension& rhs)
 613 {
 614         FloatDimension* pFloatDimension = new (std::nothrow) FloatDimension(rhs);
 615         CREATE_VARIANT_IMPL(VARIANT_TYPE_FLOAT_DIMENSION, pFloatDimension, pFloatDimension);
 616
 617         return (*this);
 618 }
 619
 620 Variant&
 621 Variant::operator =(const FloatMatrix4& rhs)
 622 {
 623         FloatMatrix4* pFloatMatrix4 = new (std::nothrow) FloatMatrix4(rhs);
 624         CREATE_VARIANT_IMPL(VARIANT_TYPE_FLOAT_MATRIX4, pFloatMatrix4, pFloatMatrix4);
 625
 626         return (*this);
 627 }
 628
 629 bool
 630 operator ==(const Variant& lhs, const Variant& rhs)
 631 {
 632         const _VariantImpl* pLhsImpl = lhs.GetVariantImpl();
 633         const _VariantImpl* pRhsImpl = rhs.GetVariantImpl();
 634
 635         if (pLhsImpl == null || pRhsImpl == null)
 636         {
 637                 return false;
 638         }
 639
 640         if (pLhsImpl == pRhsImpl)
 641         {
 642                 return true;
 643         }
 644
 645         if (pLhsImpl->__type != pRhsImpl->__type)
 646         {
 647                 return false;
 648         }
 649
 650         switch (pLhsImpl->__type)
 651         {
 652         case VARIANT_TYPE_INT:
 653                 return pLhsImpl->__data.valueInt == pRhsImpl->__data.valueInt;
 654
 655         case VARIANT_TYPE_UINT:
 656                 return pLhsImpl->__data.valueUInt == pRhsImpl->__data.valueUInt;
 657
 658         case VARIANT_TYPE_BOOL:
 659                 return pLhsImpl->__data.valueBool == pRhsImpl->__data.valueBool;
 660
 661         case VARIANT_TYPE_FLOAT:
 662                 return pLhsImpl->__data.valueFloat == pRhsImpl->__data.valueFloat;
 663
 664         case VARIANT_TYPE_DOUBLE:
 665                 return pLhsImpl->__data.valueDouble == pRhsImpl->__data.valueDouble;
 666
 667         case VARIANT_TYPE_LONG:
 668                 return pLhsImpl->__data.valueLong == pRhsImpl->__data.valueLong;
 669
 670         case VARIANT_TYPE_ULONG:
 671                 return pLhsImpl->__data.valueULong == pRhsImpl->__data.valueULong;
 672
 673         case VARIANT_TYPE_LONGLONG:
 674                 return pLhsImpl->__data.valueLongLong == pRhsImpl->__data.valueLongLong;
 675
 676         case VARIANT_TYPE_ULONGLONG:
 677                 return pLhsImpl->__data.valueULongLong == pRhsImpl->__data.valueULongLong;
 678
 679         case VARIANT_TYPE_STRING:
 680         {
 681                 if (pLhsImpl->__data.pString)
 682                 {
 683                         return (*pLhsImpl->__data.pString == *pRhsImpl->__data.pString);
 684                 }
 685                 else
 686                 {
 687                         return false;
 688                 }
 689         }
 690
 691         case VARIANT_TYPE_DATETIME:
 692         {
 693                 if (pLhsImpl->__data.pDateTime)
 694                 {
 695                         return *pLhsImpl->__data.pDateTime == *pRhsImpl->__data.pDateTime;
 696                 }
 697                 else
 698                 {
 699                         return false;
 700                 }
 701         }
 702
 703         case VARIANT_TYPE_COLOR:
 704         {
 705                 if (pLhsImpl->__data.pColor)
 706                 {
 707                         return *pLhsImpl->__data.pColor == *pRhsImpl->__data.pColor;
 708                 }
 709                 else
 710                 {
 711                         return false;
 712                 }
 713         }
 714
 715         case VARIANT_TYPE_POINT:
 716         {
 717                 if (pLhsImpl->__data.pPoint)
 718                 {
 719                         return *pLhsImpl->__data.pPoint == *pRhsImpl->__data.pPoint;
 720                 }
 721                 else
 722                 {
 723                         return false;
 724                 }
 725         }
 726
 727         case VARIANT_TYPE_FLOAT_POINT:
 728         {
 729                 if (pLhsImpl->__data.pFloatPoint)
 730                 {
 731                         return *pLhsImpl->__data.pFloatPoint == *pRhsImpl->__data.pFloatPoint;
 732                 }
 733                 else
 734                 {
 735                         return false;
 736                 }
 737         }
 738
 739         case VARIANT_TYPE_RECTANGLE:
 740         {
 741                 if (pLhsImpl->__data.pRect)
 742                 {
 743                         return *pLhsImpl->__data.pRect == *pRhsImpl->__data.pRect;
 744                 }
 745                 else
 746                 {
 747                         return false;
 748                 }
 749         }
 750
 751         case VARIANT_TYPE_FLOAT_RECTANGLE:
 752         {
 753                 if (pLhsImpl->__data.pRectf)
 754                 {
 755                         return *pLhsImpl->__data.pRectf == *pRhsImpl->__data.pRectf;
 756                 }
 757                 else
 758                 {
 759                         return false;
 760                 }
 761         }
 762
 763         case VARIANT_TYPE_DIMENSION:
 764         {
 765                 if (pLhsImpl->__data.pDimension)
 766                 {
 767                         return *pLhsImpl->__data.pDimension == *pRhsImpl->__data.pDimension;
 768                 }
 769                 else
 770                 {
 771                         return false;
 772                 }
 773         }
 774
 775         case VARIANT_TYPE_FLOAT_DIMENSION:
 776         {
 777                 if (pLhsImpl->__data.pFloatDimension)
 778                 {
 779                         return *pLhsImpl->__data.pFloatDimension == *pRhsImpl->__data.pFloatDimension;
 780                 }
 781                 else
 782                 {
 783                         return false;
 784                 }
 785         }
 786
 787         case VARIANT_TYPE_FLOAT_MATRIX4:
 788         {
 789                 if (pLhsImpl->__data.pFloatMatrix4)
 790                 {
 791                         return *pLhsImpl->__data.pFloatMatrix4 == *pRhsImpl->__data.pFloatMatrix4;
 792                 }
 793                 else
 794                 {
 795                         return false;
 796                 }
 797         }
 798
 799         case VARIANT_TYPE_NONE:
 800                 return pLhsImpl->__type == pRhsImpl->__type;
 801
 802         default:
 803                 return false;
 804         }
 805
 806         return false;
 807 }
 808
 809 bool
 810 operator !=(const Variant& lhs, const Variant& rhs)
 811 {
 812         return !(lhs == rhs);
 813 }
 814
 815 int
 816 Variant::ToInt(void) const
 817 {
 818         const _VariantImpl* pImpl = GetVariantImpl();
 819         if (pImpl)
 820         {
 821                 if (!pImpl->IsSameType(VARIANT_TYPE_INT))
 822                 {
 823                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_INT.");
 824                 }
 825                 else
 826                 {
 827                         return pImpl->__data.valueInt;
 828                 }
 829         }
 830
 831         return 0;
 832 }
 833
 834 unsigned int
 835 Variant::ToUInt(void) const
 836 {
 837         const _VariantImpl* pImpl = GetVariantImpl();
 838         if (pImpl)
 839         {
 840                 if (!pImpl->IsSameType(VARIANT_TYPE_UINT))
 841                 {
 842                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_UINT.");
 843                 }
 844                 else
 845                 {
 846                         return pImpl->__data.valueUInt;
 847                 }
 848         }
 849         return 0;
 850 }
 851
 852 bool
 853 Variant::ToBool(void) const
 854 {
 855         const _VariantImpl* pImpl = GetVariantImpl();
 856         if (pImpl)
 857         {
 858                 if (!pImpl->IsSameType(VARIANT_TYPE_BOOL))
 859                 {
 860                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_BOOL.");
 861                 }
 862                 else
 863                 {
 864                         return pImpl->__data.valueBool;
 865                 }
 866         }
 867
 868         return false;
 869 }
 870
 871 float
 872 Variant::ToFloat(void) const
 873 {
 874         const _VariantImpl* pImpl = GetVariantImpl();
 875         if (pImpl)
 876         {
 877                 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT))
 878                 {
 879                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOAT.");
 880                 }
 881                 else
 882                 {
 883                         return pImpl->__data.valueFloat;
 884                 }
 885         }
 886
 887         return 0;
 888 }
 889
 890 double
 891 Variant::ToDouble(void) const
 892 {
 893         const _VariantImpl* pImpl = GetVariantImpl();
 894         if (pImpl)
 895         {
 896                 if (!pImpl->IsSameType(VARIANT_TYPE_DOUBLE))
 897                 {
 898                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_DOUBLE.");
 899                 }
 900                 else
 901                 {
 902                         return pImpl->__data.valueDouble;
 903                 }
 904         }
 905
 906         return 0;
 907 }
 908
 909 long
 910 Variant::ToLong(void) const
 911 {
 912         const _VariantImpl* pImpl = GetVariantImpl();
 913         if (pImpl)
 914         {
 915                 if (!pImpl->IsSameType(VARIANT_TYPE_LONG))
 916                 {
 917                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_LONG.");
 918                 }
 919                 else
 920                 {
 921                         return pImpl->__data.valueLong;
 922                 }
 923         }
 924
 925         return 0;
 926 }
 927
 928 unsigned long
 929 Variant::ToULong(void) const
 930 {
 931         const _VariantImpl* pImpl = GetVariantImpl();
 932         if (pImpl)
 933         {
 934                 if (!pImpl->IsSameType(VARIANT_TYPE_ULONG))
 935                 {
 936                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_ULONG.");
 937                 }
 938                 else
 939                 {
 940                         return pImpl->__data.valueULong;
 941                 }
 942         }
 943
 944         return 0;
 945 }
 946
 947 long long
 948 Variant::ToLongLong(void) const
 949 {
 950         const _VariantImpl* pImpl = GetVariantImpl();
 951         if (pImpl)
 952         {
 953                 if (!pImpl->IsSameType(VARIANT_TYPE_LONGLONG))
 954                 {
 955                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_LONGLONG.");
 956                 }
 957                 else
 958                 {
 959                         return pImpl->__data.valueLongLong;
 960                 }
 961         }
 962
 963         return 0;
 964 }
 965
 966 unsigned long long
 967 Variant::ToULongLong(void) const
 968 {
 969         const _VariantImpl* pImpl = GetVariantImpl();
 970         if (pImpl)
 971         {
 972                 if (!pImpl->IsSameType(VARIANT_TYPE_ULONGLONG))
 973                 {
 974                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_ULONGLONG.");
 975                 }
 976                 else
 977                 {
 978                         return pImpl->__data.valueULongLong;
 979                 }
 980         }
 981
 982         return 0;
 983 }
 984
 985 String
 986 Variant::ToString(void) const
 987 {
 988         const _VariantImpl* pImpl = GetVariantImpl();
 989         if (pImpl)
 990         {
 991                 if (!pImpl->IsSameType(VARIANT_TYPE_STRING))
 992                 {
 993                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_STRING.");
 994                 }
 995                 else
 996                 {
 997                         return *pImpl->__data.pString;
 998                 }
 999         }
1000
1001         return String("");
1002 }
1003
1004 DateTime
1005 Variant::ToDateTime(void) const
1006 {
1007         const _VariantImpl* pImpl = GetVariantImpl();
1008         if (pImpl)
1009         {
1010                 if (!pImpl->IsSameType(VARIANT_TYPE_DATETIME))
1011                 {
1012                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_DATETIME.");
1013                 }
1014                 else
1015                 {
1016                         return *pImpl->__data.pDateTime;
1017                 }
1018         }
1019
1020         return DateTime();
1021 }
1022
1023 Color
1024 Variant::ToColor(void) const
1025 {
1026         const _VariantImpl* pImpl = GetVariantImpl();
1027         if (pImpl)
1028         {
1029                 if (!pImpl->IsSameType(VARIANT_TYPE_COLOR))
1030                 {
1031                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_COLOR.");
1032                 }
1033                 else
1034                 {
1035                         return *pImpl->__data.pColor;
1036                 }
1037         }
1038
1039         return Color();
1040 }
1041
1042 Point
1043 Variant::ToPoint(void) const
1044 {
1045         const _VariantImpl* pImpl = GetVariantImpl();
1046         if (pImpl)
1047         {
1048                 if (!pImpl->IsSameType(VARIANT_TYPE_POINT))
1049                 {
1050                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_POINT.");
1051                 }
1052                 else
1053                 {
1054                         return *pImpl->__data.pPoint;
1055                 }
1056         }
1057
1058         return Point();
1059 }
1060
1061 FloatPoint
1062 Variant::ToFloatPoint(void) const
1063 {
1064         const _VariantImpl* pImpl = GetVariantImpl();
1065         if (pImpl)
1066         {
1067                 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT_POINT))
1068                 {
1069                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOATPOINT.");
1070                 }
1071                 else
1072                 {
1073                         return *pImpl->__data.pFloatPoint;
1074                 }
1075         }
1076
1077         return FloatPoint();
1078 }
1079
1080 Rectangle
1081 Variant::ToRectangle(void) const
1082 {
1083         const _VariantImpl* pImpl = GetVariantImpl();
1084         if (pImpl)
1085         {
1086                 if (!pImpl->IsSameType(VARIANT_TYPE_RECTANGLE))
1087                 {
1088                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_RECTANGLE.");
1089                 }
1090                 else
1091                 {
1092                         return *pImpl->__data.pRect;
1093                 }
1094         }
1095
1096         return Rectangle();
1097 }
1098
1099 FloatRectangle
1100 Variant::ToFloatRectangle(void) const
1101 {
1102         const _VariantImpl* pImpl = GetVariantImpl();
1103         if (pImpl)
1104         {
1105                 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT_RECTANGLE))
1106                 {
1107                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOAT_RECTANGLE.");
1108                 }
1109                 else
1110                 {
1111                         return *pImpl->__data.pRectf;
1112                 }
1113         }
1114
1115         return FloatRectangle();
1116 }
1117
1118 Dimension
1119 Variant::ToDimension(void) const
1120 {
1121         const _VariantImpl* pImpl = GetVariantImpl();
1122         if (pImpl)
1123         {
1124                 if (!pImpl->IsSameType(VARIANT_TYPE_DIMENSION))
1125                 {
1126                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_DIMENSION.");
1127                 }
1128                 else
1129                 {
1130                         return *pImpl->__data.pDimension;
1131                 }
1132         }
1133
1134         return Dimension();
1135 }
1136
1137 FloatDimension
1138 Variant::ToFloatDimension(void) const
1139 {
1140         const _VariantImpl* pImpl = GetVariantImpl();
1141         if (pImpl)
1142         {
1143                 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT_DIMENSION))
1144                 {
1145                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOAT_DIMENSION.");
1146                 }
1147                 else
1148                 {
1149                         return *pImpl->__data.pFloatDimension;
1150                 }
1151         }
1152
1153         return FloatDimension();
1154 }
1155
1156 FloatMatrix4
1157 Variant::ToFloatMatrix4(void) const
1158 {
1159         const _VariantImpl* pImpl = GetVariantImpl();
1160         if (pImpl)
1161         {
1162                 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT_MATRIX4))
1163                 {
1164                         SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOAT_MATRIX4.");
1165                 }
1166                 else
1167                 {
1168                         return *pImpl->__data.pFloatMatrix4;
1169                 }
1170         }
1171
1172         return FloatMatrix4();
1173 }
1174
1175 bool
1176 Variant::IsEmpty(void) const
1177 {
1178         const _VariantImpl* pImpl = GetVariantImpl();
1179         if (pImpl)
1180         {
1181                 return pImpl->__type == VARIANT_TYPE_NONE;
1182         }
1183
1184         return false;
1185 }
1186
1187 VariantType
1188 Variant::GetType() const
1189 {
1190         const _VariantImpl* pImpl = GetVariantImpl();
1191         if (pImpl)
1192         {
1193                 return pImpl->__type;
1194         }
1195
1196         return VARIANT_TYPE_NONE;
1197 }
1198
1199 bool
1200 Variant::Equals(const Object& obj) const
1201 {
1202         const Variant* pOther = dynamic_cast <const Variant*>(&obj);
1203         if (pOther == null)
1204         {
1205                 return (false);
1206         }
1207
1208         return (*this == *pOther);
1209 }
1210
1211 int
1212 Variant::GetHashCode(void) const
1213 {
1214         const _VariantImpl* pImpl = GetVariantImpl();
1215
1216         switch (pImpl->__type)
1217         {
1218         case VARIANT_TYPE_INT:
1219                 return (int) pImpl->__data.valueInt;
1220
1221         case VARIANT_TYPE_UINT:
1222                 return (int) pImpl->__data.valueUInt;
1223
1224         case VARIANT_TYPE_BOOL:
1225                 return (int) pImpl->__data.valueBool;
1226
1227         case VARIANT_TYPE_FLOAT:
1228                 return (int) pImpl->__data.valueFloat;
1229
1230         case VARIANT_TYPE_DOUBLE:
1231                 return (int) pImpl->__data.valueDouble;
1232
1233         case VARIANT_TYPE_LONG:
1234                 return (int) pImpl->__data.valueLong;
1235
1236         case VARIANT_TYPE_ULONG:
1237                 return (int) pImpl->__data.valueULong;
1238
1239         case VARIANT_TYPE_LONGLONG:
1240                 return (int) pImpl->__data.valueLongLong;
1241
1242         case VARIANT_TYPE_ULONGLONG:
1243                 return (int) pImpl->__data.valueULongLong;
1244
1245         case VARIANT_TYPE_STRING:
1246         {
1247                 if (pImpl->__data.pString)
1248                 {
1249                         return pImpl->__data.pString->GetHashCode();
1250                 }
1251                 else
1252                 {
1253                         break;
1254                 }
1255         }
1256
1257         case VARIANT_TYPE_DATETIME:
1258         {
1259                 if (pImpl->__data.pDateTime)
1260                 {
1261                         return (pImpl->__data.pDateTime)->GetHashCode();
1262                 }
1263                 else
1264                 {
1265                         break;
1266                 }
1267         }
1268
1269         case VARIANT_TYPE_COLOR:
1270         {
1271                 if (pImpl->__data.pPoint)
1272                 {
1273                         return (pImpl->__data.pColor)->GetHashCode();
1274                 }
1275                 else
1276                 {
1277                         break;
1278                 }
1279         }
1280
1281         case VARIANT_TYPE_POINT:
1282         {
1283                 if (pImpl->__data.pPoint)
1284                 {
1285                         return (pImpl->__data.pPoint)->GetHashCode();
1286                 }
1287                 else
1288                 {
1289                         break;
1290                 }
1291         }
1292
1293         case VARIANT_TYPE_FLOAT_POINT:
1294         {
1295                 if (pImpl->__data.pFloatPoint)
1296                 {
1297                         return (pImpl->__data.pFloatPoint)->GetHashCode();
1298                 }
1299                 else
1300                 {
1301                         break;
1302                 }
1303         }
1304
1305         case VARIANT_TYPE_RECTANGLE:
1306         {
1307                 if (pImpl->__data.pRect)
1308                 {
1309                         return (pImpl->__data.pRect)->GetHashCode();
1310                 }
1311                 else
1312                 {
1313                         break;
1314                 }
1315         }
1316
1317         case VARIANT_TYPE_FLOAT_RECTANGLE:
1318         {
1319                 if (pImpl->__data.pRectf)
1320                 {
1321                         return (pImpl->__data.pRectf)->GetHashCode();
1322                 }
1323                 else
1324                 {
1325                         break;
1326                 }
1327         }
1328
1329         case VARIANT_TYPE_DIMENSION:
1330         {
1331                 if (pImpl->__data.pDimension)
1332                 {
1333                         return (pImpl->__data.pDimension)->GetHashCode();
1334                 }
1335                 else
1336                 {
1337                         break;
1338                 }
1339         }
1340
1341         case VARIANT_TYPE_FLOAT_DIMENSION:
1342         {
1343                 if (pImpl->__data.pFloatDimension)
1344                 {
1345                         return (pImpl->__data.pFloatDimension)->GetHashCode();
1346                 }
1347                 else
1348                 {
1349                         break;
1350                 }
1351         }
1352
1353         case VARIANT_TYPE_FLOAT_MATRIX4:
1354         {
1355                 if (pImpl->__data.pFloatMatrix4)
1356                 {
1357                         return (pImpl->__data.pFloatMatrix4)->GetHashCode();
1358                 }
1359                 else
1360                 {
1361                         break;
1362                 }
1363         }
1364
1365         case VARIANT_TYPE_NONE:
1366         default:
1367                 break;
1368         }
1369
1370         return 0;
1371 }
1372
1373 const _VariantImpl*
1374 Variant::GetVariantImpl(void) const
1375 {
1376         return static_cast <const _VariantImpl*>(__pVariantImpl);
1377 }
1378
1379 _VariantImpl*
1380 Variant::GetVariantImpl(void)
1381 {
1382         return __pVariantImpl;
1383 }
1384
1385 } } //Tizen::Ui