2 // Open Service Platform
3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
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
9 // http://www.apache.org/licenses/LICENSE-2.0/
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.
18 * @file FUIVariant.cpp
19 * @brief This is the implementation file for Variant class.
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 <FGrpFloatPoint3.h>
37 #include <FGrpFloatVector4.h>
38 #include <FBaseSysLog.h>
39 #include "FUi_VariantImpl.h"
41 using namespace Tizen::Base;
42 using namespace Tizen::Graphics;
44 namespace Tizen { namespace Ui
47 const Variant Variant::NULL_VARIANT;
49 Variant::Variant(void)
50 : __pVariantImpl(null)
52 __pVariantImpl = new (std::nothrow) _VariantImpl;
53 if (__pVariantImpl == null)
55 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
59 Variant::~Variant(void)
63 __pVariantImpl->Release();
66 __pVariantImpl = null;
69 Variant::Variant(const Variant& value)
70 : __pVariantImpl(null)
72 SysAssertf(value.__pVariantImpl, "No data in rhs for copy ctor");
73 __pVariantImpl = value.__pVariantImpl;
74 __pVariantImpl->AddRef();
77 Variant::Variant(int value)
78 : __pVariantImpl(null)
80 __pVariantImpl = new (std::nothrow) _VariantImpl;
81 if (__pVariantImpl == null)
83 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
87 __pVariantImpl->__type = VARIANT_TYPE_INT;
88 __pVariantImpl->__data.valueInt = 0;
89 __pVariantImpl->__data.valueInt = value;
93 Variant::Variant(unsigned int value)
94 : __pVariantImpl(null)
96 __pVariantImpl = new (std::nothrow) _VariantImpl;
97 if (__pVariantImpl == null)
99 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
103 __pVariantImpl->__type = VARIANT_TYPE_UINT;
104 __pVariantImpl->__data.valueUInt = 0;
105 __pVariantImpl->__data.valueUInt = value;
109 Variant::Variant(bool value)
110 : __pVariantImpl(null)
112 __pVariantImpl = new (std::nothrow) _VariantImpl;
113 if (__pVariantImpl == null)
115 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
119 __pVariantImpl->__type = VARIANT_TYPE_BOOL;
120 __pVariantImpl->__data.valueBool = true;
121 __pVariantImpl->__data.valueBool = value;
125 Variant::Variant(float value)
126 : __pVariantImpl(null)
128 __pVariantImpl = new (std::nothrow) _VariantImpl;
129 if (__pVariantImpl == null)
131 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
135 __pVariantImpl->__type = VARIANT_TYPE_FLOAT;
136 __pVariantImpl->__data.valueFloat = 0;
137 __pVariantImpl->__data.valueFloat = value;
141 Variant::Variant(double value)
142 : __pVariantImpl(null)
144 __pVariantImpl = new (std::nothrow) _VariantImpl;
145 if (__pVariantImpl == null)
147 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
151 __pVariantImpl->__type = VARIANT_TYPE_DOUBLE;
152 __pVariantImpl->__data.valueDouble = 0;
153 __pVariantImpl->__data.valueDouble = value;
157 Variant::Variant(long value)
158 : __pVariantImpl(null)
160 __pVariantImpl = new (std::nothrow) _VariantImpl;
161 if (__pVariantImpl == null)
163 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
167 __pVariantImpl->__type = VARIANT_TYPE_LONG;
168 __pVariantImpl->__data.valueLong = 0;
169 __pVariantImpl->__data.valueLong = value;
173 Variant::Variant(unsigned long value)
174 : __pVariantImpl(null)
176 __pVariantImpl = new (std::nothrow) _VariantImpl;
177 if (__pVariantImpl == null)
179 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
183 __pVariantImpl->__type = VARIANT_TYPE_ULONG;
184 __pVariantImpl->__data.valueULong = 0;
185 __pVariantImpl->__data.valueULong = value;
189 Variant::Variant(long long value)
190 : __pVariantImpl(null)
192 __pVariantImpl = new (std::nothrow) _VariantImpl;
193 if (__pVariantImpl == null)
195 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
199 __pVariantImpl->__type = VARIANT_TYPE_LONGLONG;
200 __pVariantImpl->__data.valueLongLong = 0;
201 __pVariantImpl->__data.valueLongLong = value;
205 Variant::Variant(unsigned long long value)
206 : __pVariantImpl(null)
208 __pVariantImpl = new (std::nothrow) _VariantImpl;
209 if (__pVariantImpl == null)
211 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
215 __pVariantImpl->__type = VARIANT_TYPE_ULONGLONG;
216 __pVariantImpl->__data.valueULongLong = 0;
217 __pVariantImpl->__data.valueULongLong = value;
221 Variant::Variant(const char* pValue)
222 : __pVariantImpl(null)
224 __pVariantImpl = new (std::nothrow) _VariantImpl;
225 if (__pVariantImpl == null)
227 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
231 __pVariantImpl->__type = VARIANT_TYPE_STRING;
232 __pVariantImpl->__data.pString = null;
233 __pVariantImpl->__data.pString = new (std::nothrow) String(pValue);
237 Variant::Variant(const wchar_t* pValue)
238 : __pVariantImpl(null)
240 __pVariantImpl = new (std::nothrow) _VariantImpl;
241 if (__pVariantImpl == null)
243 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
247 __pVariantImpl->__type = VARIANT_TYPE_STRING;
248 __pVariantImpl->__data.pString = null;
249 __pVariantImpl->__data.pString = new (std::nothrow) String(pValue);
253 Variant::Variant(const String& value)
254 : __pVariantImpl(null)
256 __pVariantImpl = new (std::nothrow) _VariantImpl;
257 if (__pVariantImpl == null)
259 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
263 __pVariantImpl->__type = VARIANT_TYPE_STRING;
264 __pVariantImpl->__data.pString = null;
265 __pVariantImpl->__data.pString = new (std::nothrow) String(value);
269 Variant::Variant(const DateTime& value)
270 : __pVariantImpl(null)
272 __pVariantImpl = new (std::nothrow) _VariantImpl;
273 if (__pVariantImpl == null)
275 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
279 __pVariantImpl->__type = VARIANT_TYPE_DATETIME;
280 __pVariantImpl->__data.pDateTime = null;
281 __pVariantImpl->__data.pDateTime = new (std::nothrow) DateTime(value);
285 Variant::Variant(const Color& value)
286 : __pVariantImpl(null)
288 __pVariantImpl = new (std::nothrow) _VariantImpl;
289 if (__pVariantImpl == null)
291 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
295 __pVariantImpl->__type = VARIANT_TYPE_COLOR;
296 __pVariantImpl->__data.pColor = null;
297 __pVariantImpl->__data.pColor = new (std::nothrow) Color(value);
301 Variant::Variant(const Point& value)
302 : __pVariantImpl(null)
304 __pVariantImpl = new (std::nothrow) _VariantImpl;
305 if (__pVariantImpl == null)
307 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
311 __pVariantImpl->__type = VARIANT_TYPE_POINT;
312 __pVariantImpl->__data.pPoint = null;
313 __pVariantImpl->__data.pPoint = new (std::nothrow) Point(value);
317 Variant::Variant(const FloatPoint& value)
318 : __pVariantImpl(null)
320 __pVariantImpl = new (std::nothrow) _VariantImpl;
321 if (__pVariantImpl == null)
323 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
327 __pVariantImpl->__type = VARIANT_TYPE_FLOAT_POINT;
328 __pVariantImpl->__data.pFloatPoint = null;
329 __pVariantImpl->__data.pFloatPoint = new (std::nothrow) FloatPoint(value);
333 Variant::Variant(const Rectangle& value)
334 : __pVariantImpl(null)
336 __pVariantImpl = new (std::nothrow) _VariantImpl;
337 if (__pVariantImpl == null)
339 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
343 __pVariantImpl->__type = VARIANT_TYPE_RECTANGLE;
344 __pVariantImpl->__data.pRect = null;
345 __pVariantImpl->__data.pRect = new (std::nothrow) Rectangle(value);
349 Variant::Variant(const FloatRectangle& value)
350 : __pVariantImpl(null)
352 __pVariantImpl = new (std::nothrow) _VariantImpl;
353 if (__pVariantImpl == null)
355 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
359 __pVariantImpl->__type = VARIANT_TYPE_FLOAT_RECTANGLE;
360 __pVariantImpl->__data.pRectf = null;
361 __pVariantImpl->__data.pRectf = new (std::nothrow) FloatRectangle(value);
365 Variant::Variant(const Dimension& value)
366 : __pVariantImpl(null)
368 __pVariantImpl = new (std::nothrow) _VariantImpl;
369 if (__pVariantImpl == null)
371 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
375 __pVariantImpl->__type = VARIANT_TYPE_DIMENSION;
376 __pVariantImpl->__data.pDimension = null;
377 __pVariantImpl->__data.pDimension = new (std::nothrow) Dimension(value);
381 Variant::Variant(const FloatDimension& value)
382 : __pVariantImpl(null)
384 __pVariantImpl = new (std::nothrow) _VariantImpl;
385 if (__pVariantImpl == null)
387 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
391 __pVariantImpl->__type = VARIANT_TYPE_FLOAT_DIMENSION;
392 __pVariantImpl->__data.pFloatDimension = null;
393 __pVariantImpl->__data.pFloatDimension = new (std::nothrow) FloatDimension(value);
397 Variant::Variant(const FloatMatrix4& value)
398 : __pVariantImpl(null)
400 __pVariantImpl = new (std::nothrow) _VariantImpl;
401 if (__pVariantImpl == null)
403 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
407 __pVariantImpl->__type = VARIANT_TYPE_FLOAT_MATRIX4;
408 __pVariantImpl->__data.pFloatMatrix4 = null;
409 __pVariantImpl->__data.pFloatMatrix4 = new (std::nothrow) FloatMatrix4(value);
413 Variant::Variant(const Tizen::Graphics::FloatPoint3& value)
414 : __pVariantImpl(null)
416 __pVariantImpl = new (std::nothrow) _VariantImpl;
417 if (__pVariantImpl == null)
419 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
423 __pVariantImpl->__type = VARIANT_TYPE_FLOAT_POINT3;
424 __pVariantImpl->__data.pFloatPoint3 = null;
425 __pVariantImpl->__data.pFloatPoint3 = new (std::nothrow) FloatPoint3(value);
429 Variant::Variant(const Tizen::Graphics::FloatVector4& value)
430 : __pVariantImpl(null)
432 __pVariantImpl = new (std::nothrow) _VariantImpl;
433 if (__pVariantImpl == null)
435 SysLogException(NID_UI, E_SYSTEM, "[E_OUT_OF_MEMORY] pImpl is null.");
439 __pVariantImpl->__type = VARIANT_TYPE_FLOAT_VECTOR4;
440 __pVariantImpl->__data.pFloatVector4 = null;
441 __pVariantImpl->__data.pFloatVector4 = new (std::nothrow) FloatVector4(value);
445 // Assignment Operators
447 Variant::operator =(const Variant& rhs)
451 if (__pVariantImpl && rhs.__pVariantImpl && __pVariantImpl != rhs.__pVariantImpl)
453 __pVariantImpl->Release();
454 __pVariantImpl = rhs.__pVariantImpl;
455 __pVariantImpl->AddRef();
461 #define CREATE_VARIANT_IMPL(type, member, value) \
463 if (!__pVariantImpl || __pVariantImpl->__type != type) \
465 _VariantImpl* pImpl = new (std::nothrow) _VariantImpl; \
468 pImpl->__type = type; \
469 pImpl->__data.member = value; \
470 delete __pVariantImpl; \
471 __pVariantImpl = pImpl; \
476 /* __pVariantImpl != null && __pVariantImpl->__type == type */ \
477 __pVariantImpl->__data.member = value; \
481 #define CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(type, member, value) \
483 if (!__pVariantImpl || __pVariantImpl->__type != type) \
485 _VariantImpl* pImpl = new (std::nothrow) _VariantImpl; \
488 pImpl->__type = type; \
489 pImpl->__data.member = value; \
490 delete __pVariantImpl; \
491 __pVariantImpl = pImpl; \
496 /* __pVariantImpl != null && __pVariantImpl->__type == type */ \
497 delete __pVariantImpl->__data.member; \
498 __pVariantImpl->__data.member = value; \
503 Variant::operator =(int rhs)
505 CREATE_VARIANT_IMPL(VARIANT_TYPE_INT, valueInt, rhs);
511 Variant::operator =(unsigned int rhs)
513 CREATE_VARIANT_IMPL(VARIANT_TYPE_UINT, valueUInt, rhs);
519 Variant::operator =(bool rhs)
521 CREATE_VARIANT_IMPL(VARIANT_TYPE_BOOL, valueBool, rhs);
527 Variant::operator =(float rhs)
529 CREATE_VARIANT_IMPL(VARIANT_TYPE_FLOAT, valueFloat, rhs);
535 Variant::operator =(double rhs)
537 CREATE_VARIANT_IMPL(VARIANT_TYPE_DOUBLE, valueDouble, rhs);
543 Variant::operator =(long rhs)
545 CREATE_VARIANT_IMPL(VARIANT_TYPE_LONG, valueLong, rhs);
551 Variant::operator =(unsigned long rhs)
553 CREATE_VARIANT_IMPL(VARIANT_TYPE_ULONG, valueULong, rhs);
559 Variant::operator =(long long rhs)
561 CREATE_VARIANT_IMPL(VARIANT_TYPE_LONGLONG, valueLongLong, rhs);
567 Variant::operator =(unsigned long long rhs)
569 CREATE_VARIANT_IMPL(VARIANT_TYPE_ULONGLONG, valueLongLong, rhs);
575 Variant::operator =(const char* pRhs)
577 String* pString = new (std::nothrow) String(pRhs);
578 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_STRING, pString, pString);
584 Variant::operator =(const wchar_t* pRhs)
586 String* pString = new (std::nothrow) String(pRhs);
587 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_STRING, pString, pString);
593 Variant::operator =(const String& rhs)
595 String* pString = new (std::nothrow) String(rhs);
596 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_STRING, pString, pString);
602 Variant::operator =(const DateTime& rhs)
604 DateTime* pDateTime = new (std::nothrow) DateTime(rhs);
605 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_DATETIME, pDateTime, pDateTime);
611 Variant::operator =(const Color& rhs)
613 Color* pColor = new (std::nothrow) Color(rhs);
614 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_COLOR, pColor, pColor);
620 Variant::operator =(const Point& rhs)
622 Point* pPoint = new (std::nothrow) Point(rhs);
623 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_POINT, pPoint, pPoint);
629 Variant::operator =(const FloatPoint& rhs)
631 FloatPoint* pFloatPoint = new (std::nothrow) FloatPoint(rhs);
632 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_FLOAT_POINT, pFloatPoint, pFloatPoint);
638 Variant::operator =(const Rectangle& rhs)
640 Rectangle* pRectangle = new (std::nothrow) Rectangle(rhs);
641 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_RECTANGLE, pRect, pRectangle);
647 Variant::operator =(const FloatRectangle& rhs)
649 FloatRectangle* pFloatRectangle = new (std::nothrow) FloatRectangle(rhs);
650 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_FLOAT_RECTANGLE, pRectf, pFloatRectangle);
656 Variant::operator =(const Dimension& rhs)
659 Dimension* pDimension = new (std::nothrow) Dimension(rhs);
660 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_DIMENSION, pDimension, pDimension);
666 Variant::operator =(const FloatDimension& rhs)
668 FloatDimension* pFloatDimension = new (std::nothrow) FloatDimension(rhs);
669 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_FLOAT_DIMENSION, pFloatDimension, pFloatDimension);
675 Variant::operator =(const FloatMatrix4& rhs)
677 FloatMatrix4* pFloatMatrix4 = new (std::nothrow) FloatMatrix4(rhs);
678 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_FLOAT_MATRIX4, pFloatMatrix4, pFloatMatrix4);
684 Variant::operator =(const Tizen::Graphics::FloatPoint3& rhs)
686 FloatPoint3* pFloatPoint3 = new (std::nothrow) FloatPoint3(rhs);
687 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_FLOAT_POINT3, pFloatPoint3, pFloatPoint3);
693 Variant::operator =(const Tizen::Graphics::FloatVector4& rhs)
695 FloatVector4* pFloatVector4 = new (std::nothrow) FloatVector4(rhs);
696 CREATE_VARIANT_IMPL_DELETE_PREVIOUS_VALE(VARIANT_TYPE_FLOAT_VECTOR4, pFloatVector4, pFloatVector4);
702 operator ==(const Variant& lhs, const Variant& rhs)
704 const _VariantImpl* pLhsImpl = lhs.GetVariantImpl();
705 const _VariantImpl* pRhsImpl = rhs.GetVariantImpl();
707 if (pLhsImpl == null || pRhsImpl == null)
712 if (pLhsImpl == pRhsImpl)
717 if (pLhsImpl->__type != pRhsImpl->__type)
722 switch (pLhsImpl->__type)
724 case VARIANT_TYPE_INT:
725 return pLhsImpl->__data.valueInt == pRhsImpl->__data.valueInt;
727 case VARIANT_TYPE_UINT:
728 return pLhsImpl->__data.valueUInt == pRhsImpl->__data.valueUInt;
730 case VARIANT_TYPE_BOOL:
731 return pLhsImpl->__data.valueBool == pRhsImpl->__data.valueBool;
733 case VARIANT_TYPE_FLOAT:
734 return pLhsImpl->__data.valueFloat == pRhsImpl->__data.valueFloat;
736 case VARIANT_TYPE_DOUBLE:
737 return pLhsImpl->__data.valueDouble == pRhsImpl->__data.valueDouble;
739 case VARIANT_TYPE_LONG:
740 return pLhsImpl->__data.valueLong == pRhsImpl->__data.valueLong;
742 case VARIANT_TYPE_ULONG:
743 return pLhsImpl->__data.valueULong == pRhsImpl->__data.valueULong;
745 case VARIANT_TYPE_LONGLONG:
746 return pLhsImpl->__data.valueLongLong == pRhsImpl->__data.valueLongLong;
748 case VARIANT_TYPE_ULONGLONG:
749 return pLhsImpl->__data.valueULongLong == pRhsImpl->__data.valueULongLong;
751 case VARIANT_TYPE_STRING:
753 if (pLhsImpl->__data.pString)
755 return (*pLhsImpl->__data.pString == *pRhsImpl->__data.pString);
763 case VARIANT_TYPE_DATETIME:
765 if (pLhsImpl->__data.pDateTime)
767 return *pLhsImpl->__data.pDateTime == *pRhsImpl->__data.pDateTime;
775 case VARIANT_TYPE_COLOR:
777 if (pLhsImpl->__data.pColor)
779 return *pLhsImpl->__data.pColor == *pRhsImpl->__data.pColor;
787 case VARIANT_TYPE_POINT:
789 if (pLhsImpl->__data.pPoint)
791 return *pLhsImpl->__data.pPoint == *pRhsImpl->__data.pPoint;
799 case VARIANT_TYPE_FLOAT_POINT:
801 if (pLhsImpl->__data.pFloatPoint)
803 return *pLhsImpl->__data.pFloatPoint == *pRhsImpl->__data.pFloatPoint;
811 case VARIANT_TYPE_RECTANGLE:
813 if (pLhsImpl->__data.pRect)
815 return *pLhsImpl->__data.pRect == *pRhsImpl->__data.pRect;
823 case VARIANT_TYPE_FLOAT_RECTANGLE:
825 if (pLhsImpl->__data.pRectf)
827 return *pLhsImpl->__data.pRectf == *pRhsImpl->__data.pRectf;
835 case VARIANT_TYPE_DIMENSION:
837 if (pLhsImpl->__data.pDimension)
839 return *pLhsImpl->__data.pDimension == *pRhsImpl->__data.pDimension;
847 case VARIANT_TYPE_FLOAT_DIMENSION:
849 if (pLhsImpl->__data.pFloatDimension)
851 return *pLhsImpl->__data.pFloatDimension == *pRhsImpl->__data.pFloatDimension;
859 case VARIANT_TYPE_FLOAT_MATRIX4:
861 if (pLhsImpl->__data.pFloatMatrix4)
863 return *pLhsImpl->__data.pFloatMatrix4 == *pRhsImpl->__data.pFloatMatrix4;
871 case VARIANT_TYPE_FLOAT_POINT3:
873 if (pLhsImpl->__data.pFloatPoint3)
875 return *pLhsImpl->__data.pFloatPoint3 == *pRhsImpl->__data.pFloatPoint3;
883 case VARIANT_TYPE_FLOAT_VECTOR4:
885 if (pLhsImpl->__data.pFloatVector4)
887 return *pLhsImpl->__data.pFloatVector4 == *pRhsImpl->__data.pFloatVector4;
895 case VARIANT_TYPE_NONE:
896 return pLhsImpl->__type == pRhsImpl->__type;
906 operator !=(const Variant& lhs, const Variant& rhs)
908 return !(lhs == rhs);
912 Variant::ToInt(void) const
914 const _VariantImpl* pImpl = GetVariantImpl();
917 if (!pImpl->IsSameType(VARIANT_TYPE_INT))
919 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_INT.");
923 return pImpl->__data.valueInt;
931 Variant::ToUInt(void) const
933 const _VariantImpl* pImpl = GetVariantImpl();
936 if (!pImpl->IsSameType(VARIANT_TYPE_UINT))
938 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_UINT.");
942 return pImpl->__data.valueUInt;
949 Variant::ToBool(void) const
951 const _VariantImpl* pImpl = GetVariantImpl();
954 if (!pImpl->IsSameType(VARIANT_TYPE_BOOL))
956 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_BOOL.");
960 return pImpl->__data.valueBool;
968 Variant::ToFloat(void) const
970 const _VariantImpl* pImpl = GetVariantImpl();
973 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT))
975 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOAT.");
979 return pImpl->__data.valueFloat;
987 Variant::ToDouble(void) const
989 const _VariantImpl* pImpl = GetVariantImpl();
992 if (!pImpl->IsSameType(VARIANT_TYPE_DOUBLE))
994 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_DOUBLE.");
998 return pImpl->__data.valueDouble;
1006 Variant::ToLong(void) const
1008 const _VariantImpl* pImpl = GetVariantImpl();
1011 if (!pImpl->IsSameType(VARIANT_TYPE_LONG))
1013 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_LONG.");
1017 return pImpl->__data.valueLong;
1025 Variant::ToULong(void) const
1027 const _VariantImpl* pImpl = GetVariantImpl();
1030 if (!pImpl->IsSameType(VARIANT_TYPE_ULONG))
1032 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_ULONG.");
1036 return pImpl->__data.valueULong;
1044 Variant::ToLongLong(void) const
1046 const _VariantImpl* pImpl = GetVariantImpl();
1049 if (!pImpl->IsSameType(VARIANT_TYPE_LONGLONG))
1051 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_LONGLONG.");
1055 return pImpl->__data.valueLongLong;
1063 Variant::ToULongLong(void) const
1065 const _VariantImpl* pImpl = GetVariantImpl();
1068 if (!pImpl->IsSameType(VARIANT_TYPE_ULONGLONG))
1070 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_ULONGLONG.");
1074 return pImpl->__data.valueULongLong;
1082 Variant::ToString(void) const
1084 const _VariantImpl* pImpl = GetVariantImpl();
1087 if (!pImpl->IsSameType(VARIANT_TYPE_STRING))
1089 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_STRING.");
1093 return *pImpl->__data.pString;
1101 Variant::ToDateTime(void) const
1103 const _VariantImpl* pImpl = GetVariantImpl();
1106 if (!pImpl->IsSameType(VARIANT_TYPE_DATETIME))
1108 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_DATETIME.");
1112 return *pImpl->__data.pDateTime;
1120 Variant::ToColor(void) const
1122 const _VariantImpl* pImpl = GetVariantImpl();
1125 if (!pImpl->IsSameType(VARIANT_TYPE_COLOR))
1127 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_COLOR.");
1131 return *pImpl->__data.pColor;
1139 Variant::ToPoint(void) const
1141 const _VariantImpl* pImpl = GetVariantImpl();
1144 if (!pImpl->IsSameType(VARIANT_TYPE_POINT))
1146 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_POINT.");
1150 return *pImpl->__data.pPoint;
1158 Variant::ToFloatPoint(void) const
1160 const _VariantImpl* pImpl = GetVariantImpl();
1163 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT_POINT))
1165 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOATPOINT.");
1169 return *pImpl->__data.pFloatPoint;
1173 return FloatPoint();
1177 Variant::ToRectangle(void) const
1179 const _VariantImpl* pImpl = GetVariantImpl();
1182 if (!pImpl->IsSameType(VARIANT_TYPE_RECTANGLE))
1184 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_RECTANGLE.");
1188 return *pImpl->__data.pRect;
1196 Variant::ToFloatRectangle(void) const
1198 const _VariantImpl* pImpl = GetVariantImpl();
1201 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT_RECTANGLE))
1203 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOAT_RECTANGLE.");
1207 return *pImpl->__data.pRectf;
1211 return FloatRectangle();
1215 Variant::ToDimension(void) const
1217 const _VariantImpl* pImpl = GetVariantImpl();
1220 if (!pImpl->IsSameType(VARIANT_TYPE_DIMENSION))
1222 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_DIMENSION.");
1226 return *pImpl->__data.pDimension;
1234 Variant::ToFloatDimension(void) const
1236 const _VariantImpl* pImpl = GetVariantImpl();
1239 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT_DIMENSION))
1241 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOAT_DIMENSION.");
1245 return *pImpl->__data.pFloatDimension;
1249 return FloatDimension();
1253 Variant::ToFloatMatrix4(void) const
1255 const _VariantImpl* pImpl = GetVariantImpl();
1258 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT_MATRIX4))
1260 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOAT_MATRIX4.");
1264 return *pImpl->__data.pFloatMatrix4;
1268 return FloatMatrix4();
1272 Variant::ToFloatPoint3(void) const
1274 const _VariantImpl* pImpl = GetVariantImpl();
1277 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT_POINT3))
1279 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOAT_POINT3.");
1283 return *pImpl->__data.pFloatPoint3;
1287 return FloatPoint3();
1291 Variant::ToFloatVector4(void) const
1293 const _VariantImpl* pImpl = GetVariantImpl();
1296 if (!pImpl->IsSameType(VARIANT_TYPE_FLOAT_VECTOR4))
1298 SysLogException(NID_UI, E_INVALID_OPERATION, "[E_INVALID_OPERATION] The current variant type is not VARIANT_TYPE_FLOAT_VECTOR4.");
1302 return *pImpl->__data.pFloatVector4;
1306 return FloatVector4();
1310 Variant::IsEmpty(void) const
1312 const _VariantImpl* pImpl = GetVariantImpl();
1315 return pImpl->__type == VARIANT_TYPE_NONE;
1322 Variant::GetType() const
1324 const _VariantImpl* pImpl = GetVariantImpl();
1327 return pImpl->__type;
1330 return VARIANT_TYPE_NONE;
1334 Variant::Equals(const Object& obj) const
1336 const Variant* pOther = dynamic_cast <const Variant*>(&obj);
1342 return (*this == *pOther);
1346 Variant::GetHashCode(void) const
1348 const _VariantImpl* pImpl = GetVariantImpl();
1350 switch (pImpl->__type)
1352 case VARIANT_TYPE_INT:
1353 return (int) pImpl->__data.valueInt;
1355 case VARIANT_TYPE_UINT:
1356 return (int) pImpl->__data.valueUInt;
1358 case VARIANT_TYPE_BOOL:
1359 return (int) pImpl->__data.valueBool;
1361 case VARIANT_TYPE_FLOAT:
1362 return (int) pImpl->__data.valueFloat;
1364 case VARIANT_TYPE_DOUBLE:
1365 return (int) pImpl->__data.valueDouble;
1367 case VARIANT_TYPE_LONG:
1368 return (int) pImpl->__data.valueLong;
1370 case VARIANT_TYPE_ULONG:
1371 return (int) pImpl->__data.valueULong;
1373 case VARIANT_TYPE_LONGLONG:
1374 return (int) pImpl->__data.valueLongLong;
1376 case VARIANT_TYPE_ULONGLONG:
1377 return (int) pImpl->__data.valueULongLong;
1379 case VARIANT_TYPE_STRING:
1381 if (pImpl->__data.pString)
1383 return pImpl->__data.pString->GetHashCode();
1391 case VARIANT_TYPE_DATETIME:
1393 if (pImpl->__data.pDateTime)
1395 return (pImpl->__data.pDateTime)->GetHashCode();
1403 case VARIANT_TYPE_COLOR:
1405 if (pImpl->__data.pPoint)
1407 return (pImpl->__data.pColor)->GetHashCode();
1415 case VARIANT_TYPE_POINT:
1417 if (pImpl->__data.pPoint)
1419 return (pImpl->__data.pPoint)->GetHashCode();
1427 case VARIANT_TYPE_FLOAT_POINT:
1429 if (pImpl->__data.pFloatPoint)
1431 return (pImpl->__data.pFloatPoint)->GetHashCode();
1439 case VARIANT_TYPE_RECTANGLE:
1441 if (pImpl->__data.pRect)
1443 return (pImpl->__data.pRect)->GetHashCode();
1451 case VARIANT_TYPE_FLOAT_RECTANGLE:
1453 if (pImpl->__data.pRectf)
1455 return (pImpl->__data.pRectf)->GetHashCode();
1463 case VARIANT_TYPE_DIMENSION:
1465 if (pImpl->__data.pDimension)
1467 return (pImpl->__data.pDimension)->GetHashCode();
1475 case VARIANT_TYPE_FLOAT_DIMENSION:
1477 if (pImpl->__data.pFloatDimension)
1479 return (pImpl->__data.pFloatDimension)->GetHashCode();
1487 case VARIANT_TYPE_FLOAT_MATRIX4:
1489 if (pImpl->__data.pFloatMatrix4)
1491 return (pImpl->__data.pFloatMatrix4)->GetHashCode();
1499 case VARIANT_TYPE_FLOAT_POINT3:
1501 if (pImpl->__data.pFloatPoint3)
1503 return (pImpl->__data.pFloatPoint3)->GetHashCode();
1511 case VARIANT_TYPE_FLOAT_VECTOR4:
1513 if (pImpl->__data.pFloatVector4)
1515 return (pImpl->__data.pFloatVector4)->GetHashCode();
1523 case VARIANT_TYPE_NONE:
1532 Variant::GetVariantImpl(void) const
1534 return static_cast <const _VariantImpl*>(__pVariantImpl);
1538 Variant::GetVariantImpl(void)
1540 return __pVariantImpl;