56020434a352387174c124cb3859bb43c7266d42
[profile/ivi/wrt-plugins-tizen.git] / src / platform / API / Filter / AnyType.cpp
1 /*
2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
3  *
4  * Licensed under the Apache License, Version 2.0 (the License);
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an AS IS BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16
17 /*
18  * @file        AnyType.cpp
19  * @author      Kisub Song (kisubs.song@samsung.com)
20  * @version     0.1
21  * @brief       Declaration of the JSFilter class
22  */
23
24 #include "AnyType.h"
25 #include <Commons/Exception.h>
26
27 namespace TizenApis {
28 namespace Api {
29 namespace Tizen {
30
31 using namespace WrtDeviceApis::Commons;
32 using namespace WrtDeviceApis::CommonsJavaScript;
33
34 AnyTypeConverter::AnyTypeConverter(JSContextRef context) :
35                 Converter(context)
36 {
37 }
38
39 AnyTypeConverter::~AnyTypeConverter()
40 {
41 }
42
43 JSValueRef AnyTypeConverter::toJSValueRef(const AnyPtr& arg)
44 {
45         PrimitiveType type = arg->getType();
46
47         if(type == PrimitiveType_Boolean)
48                 return DPL::DynamicPointerCast< Any_T<bool> >(arg)->toJSValueRef(m_context);
49         else if(type == PrimitiveType_Char)
50                 return DPL::DynamicPointerCast< Any_T<char> >(arg)->toJSValueRef(m_context);
51         else if(type == PrimitiveType_UChar)
52                 return DPL::DynamicPointerCast< Any_T<unsigned char> >(arg)->toJSValueRef(m_context);
53         else if(type == PrimitiveType_Int)
54                 return DPL::DynamicPointerCast< Any_T<int> >(arg)->toJSValueRef(m_context);
55         else if(type == PrimitiveType_UInt)
56                 return DPL::DynamicPointerCast< Any_T<unsigned int> >(arg)->toJSValueRef(m_context);
57         else if(type == PrimitiveType_Long)
58                 return DPL::DynamicPointerCast< Any_T<long> >(arg)->toJSValueRef(m_context);
59         else if(type == PrimitiveType_ULong)
60                 return DPL::DynamicPointerCast< Any_T<unsigned long> >(arg)->toJSValueRef(m_context);
61         else if(type == PrimitiveType_Double)
62                 return DPL::DynamicPointerCast< Any_T<double> >(arg)->toJSValueRef(m_context);
63         else if(type == PrimitiveType_String)
64                 return DPL::DynamicPointerCast< Any_T<std::string> >(arg)->toJSValueRef(m_context);
65         else if(type == PrimitiveType_Time)
66                 return DPL::DynamicPointerCast< Any_T<tm> >(arg)->toJSValueRef(m_context);
67         else
68                 return DPL::DynamicPointerCast< Any_T<std::string> >(arg)->toJSValueRef(m_context);
69 }
70
71 AnyPtr AnyTypeConverter::toAny(const JSValueRef &value, const PrimitiveType preferredNumberType)
72 {
73         JSType jstype = JSValueGetType(m_context, value);
74
75         if(jstype == kJSTypeBoolean)
76                 return toAny(Converter::toBool(value));
77         else if(jstype == kJSTypeNumber)
78         {
79                 if(preferredNumberType == PrimitiveType_Char)
80                         return toAny(Converter::toChar(value));
81                 else if(preferredNumberType == PrimitiveType_UChar)
82                         return toAny(Converter::toUChar(value));
83                 else if(preferredNumberType == PrimitiveType_Int)
84                         return toAny(Converter::toInt(value));
85                 else if(preferredNumberType == PrimitiveType_UInt)
86                         return toAny(static_cast<unsigned int>(Converter::toULong(value)));
87                 else if(preferredNumberType == PrimitiveType_Long)
88                         return toAny(Converter::toLong(value));
89                 else if(preferredNumberType == PrimitiveType_ULong)
90                         return toAny(Converter::toULong(value));
91                 else if(preferredNumberType == PrimitiveType_Double)
92                         return toAny(Converter::toDouble(value));
93                 else
94                         return toAny(Converter::toDouble(value));
95         }
96         else if(jstype == kJSTypeString)
97                 return toAny(Converter::toString(value));
98         else if(isDate(value))
99                 return toAny(Converter::toDateTm(value));
100         else
101                 return toAny(Converter::toString(value));
102 }
103
104 AnyPtr AnyTypeConverter::toAny(const bool &value)
105 {
106         AnyPtr ptr(new Any_T<bool>(value));
107         return ptr;
108 }
109
110 AnyPtr AnyTypeConverter::toAny(const char &value)
111 {
112         AnyPtr ptr(new Any_T<char>(value));
113         return ptr;
114 }
115
116 AnyPtr AnyTypeConverter::toAny(const unsigned char &value)
117 {
118         AnyPtr ptr(new Any_T<unsigned char>(value));
119         return ptr;
120 }
121
122 AnyPtr AnyTypeConverter::toAny(const int &value)
123 {
124         AnyPtr ptr(new Any_T<int>(value));
125         return ptr;
126 }
127
128 AnyPtr AnyTypeConverter::toAny(const unsigned int &value)
129 {
130         AnyPtr ptr(new Any_T<unsigned int>(value));
131         return ptr;
132 }
133
134 AnyPtr AnyTypeConverter::toAny(const long &value)
135 {
136         AnyPtr ptr(new Any_T<long>(value));
137         return ptr;
138 }
139
140 AnyPtr AnyTypeConverter::toAny(const unsigned long &value)
141 {
142         AnyPtr ptr(new Any_T<unsigned long>(value));
143         return ptr;
144 }
145
146 AnyPtr AnyTypeConverter::toAny(const double &value)
147 {
148         AnyPtr ptr(new Any_T<double>(value));
149         return ptr;
150 }
151
152 AnyPtr AnyTypeConverter::toAny(const std::string &value)
153 {
154         AnyPtr ptr(new Any_T<std::string>(value));
155         return ptr;
156 }
157
158 AnyPtr AnyTypeConverter::toAny(const tm &value)
159 {
160         AnyPtr ptr(new Any_T<tm>(value));
161         return ptr;
162 }
163
164 bool AnyTypeConverter::toBool(const AnyPtr& arg)
165 {
166         if(arg->getType() != PrimitiveType_Boolean)
167                 ThrowMsg(InvalidArgumentException, "Type mismatch.");
168
169         return DPL::DynamicPointerCast< Any_T<bool> >(arg)->getValue();
170 }
171
172 char AnyTypeConverter::toChar(const AnyPtr& arg)
173 {
174         if(arg->getType() != PrimitiveType_Char)
175                 ThrowMsg(InvalidArgumentException, "Type mismatch.");
176
177         return DPL::DynamicPointerCast< Any_T<char> >(arg)->getValue();
178 }
179
180 unsigned char AnyTypeConverter::toUChar(const AnyPtr& arg)
181 {
182         if(arg->getType() != PrimitiveType_UChar)
183                 ThrowMsg(InvalidArgumentException, "Type mismatch.");
184
185         return DPL::DynamicPointerCast< Any_T<unsigned char> >(arg)->getValue();
186 }
187
188 int AnyTypeConverter::toInt(const AnyPtr& arg)
189 {
190         if(arg->getType() != PrimitiveType_Int)
191                 ThrowMsg(InvalidArgumentException, "Type mismatch.");
192
193         return DPL::DynamicPointerCast< Any_T<int> >(arg)->getValue();
194 }
195
196 unsigned int AnyTypeConverter::toUInt(const AnyPtr& arg)
197 {
198         if(arg->getType() != PrimitiveType_UInt)
199                 ThrowMsg(InvalidArgumentException, "Type mismatch.");
200
201         return DPL::DynamicPointerCast< Any_T<unsigned int> >(arg)->getValue();
202 }
203
204 long AnyTypeConverter::toLong(const AnyPtr& arg)
205 {
206         if(arg->getType() != PrimitiveType_Long)
207                 ThrowMsg(InvalidArgumentException, "Type mismatch.");
208
209         return DPL::DynamicPointerCast< Any_T<long> >(arg)->getValue();
210 }
211
212 unsigned long AnyTypeConverter::toULong(const AnyPtr& arg)
213 {
214         if(arg->getType() != PrimitiveType_ULong)
215                 ThrowMsg(InvalidArgumentException, "Type mismatch.");
216
217         return DPL::DynamicPointerCast< Any_T<unsigned long> >(arg)->getValue();
218 }
219
220 double AnyTypeConverter::toDouble(const AnyPtr& arg)
221 {
222         if(arg->getType() != PrimitiveType_Double)
223                 ThrowMsg(InvalidArgumentException, "Type mismatch.");
224
225         return DPL::DynamicPointerCast< Any_T<double> >(arg)->getValue();
226 }
227
228 std::string AnyTypeConverter::toString(const AnyPtr& arg)
229 {
230         if(arg->getType() != PrimitiveType_String)
231                 ThrowMsg(InvalidArgumentException, "Type mismatch.");
232
233         return DPL::DynamicPointerCast< Any_T<std::string> >(arg)->getValue();
234 }
235
236 tm AnyTypeConverter::toDateTm(const AnyPtr& arg)
237 {
238         if(arg->getType() != PrimitiveType_Time)
239                 ThrowMsg(InvalidArgumentException, "Type mismatch.");
240
241         return DPL::DynamicPointerCast< Any_T<tm> >(arg)->getValue();
242 }
243
244 bool AnyTypeConverter::isDate(const JSValueRef& arg)
245 {
246         // this method originated from TizenApis::Commons::Validator::isDate()
247         if ( JSValueIsNull( m_context, arg ) || JSValueIsUndefined( m_context, arg ) || !JSValueIsObject( m_context, arg ) )
248                 return false;
249
250         Try {
251                 toDateTm( arg );
252         } Catch(Exception) {
253                 return false;
254         }
255         return true;
256 }
257
258 } // Tizen
259 } // Api
260 } // TizenApis