Add 'ExclusiveArch: armv7l' limit build to arm architecture
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / builder / builder-get-is.inl.h
1 #ifndef __DALI_TOOLKIT_INTERNAL_BUILDER_GET_IS_INL__
2 #define __DALI_TOOLKIT_INTERNAL_BUILDER_GET_IS_INL__
3
4 //
5 // Copyright (c) 2014 Samsung Electronics Co., Ltd.
6 //
7 // Licensed under the Flora License, Version 1.0 (the License);
8 // you may not use this file except in compliance with the License.
9 // You may obtain a copy of the License at
10 //
11 //     http://floralicense.org/license/
12 //
13 // Unless required by applicable law or agreed to in writing, software
14 // distributed under the License is distributed on an AS IS BASIS,
15 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 // See the License for the specific language governing permissions and
17 // limitations under the License.
18 //
19
20 // INTERNAL INCLUDES
21 #include <dali-toolkit/internal/builder/builder-declarations.h>
22
23 inline OptionalChild IsChild(const TreeNode* node, const std::string& childName)
24 {
25   if( node )
26   {
27     const TreeNode* c = node->GetChild(childName);
28     if( NULL != c )
29     {
30       return OptionalChild( *c );
31     }
32     else
33     {
34       return OptionalChild();
35     }
36   }
37   else
38   {
39     return OptionalChild();
40   }
41 }
42
43 inline OptionalChild IsChild(const TreeNode& node, const std::string& childName)
44 {
45   return IsChild(&node, childName);
46 }
47
48 inline OptionalString IsString(const OptionalChild& node)
49 {
50   if( node && (*node).GetType() == TreeNode::STRING )
51   {
52     return OptionalString((*node).GetString());
53   }
54   else
55   {
56     return OptionalString();
57   }
58 }
59 inline OptionalFloat IsFloat(const OptionalChild& node)
60 {
61   OptionalFloat ret;
62
63   if( node )
64   {
65     if( (*node).GetType() == TreeNode::FLOAT )
66     {
67       ret = (*node).GetFloat();
68     }
69     else if( (*node).GetType() == TreeNode::INTEGER )
70     {
71       // JSON has number not float/int but JsonParser discriminates.
72       // Here we don't care so we allow coercion
73       ret = static_cast<float>( (*node).GetInteger() );
74     }
75   }
76
77   return ret;
78 }
79
80 inline OptionalInteger IsInteger(const OptionalChild &node)
81 {
82   OptionalInteger ret;
83
84   if( node )
85   {
86     if( (*node).GetType() == TreeNode::INTEGER )
87     {
88       ret = (*node).GetInteger();
89     }
90     else if( (*node).GetType() == TreeNode::FLOAT )
91     {
92       ret = static_cast<int>(  (*node).GetFloat() );
93     }
94   }
95
96   return ret;
97 }
98
99 inline OptionalBoolean IsBoolean(const OptionalChild& node)
100 {
101   if( node && (*node).GetType() == TreeNode::BOOLEAN )
102   {
103     return OptionalBoolean(1 == (*node).GetInteger());
104   }
105   else
106   {
107     return OptionalBoolean();
108   }
109 }
110
111 // copy N Numbers
112 template <typename T>
113 inline bool CopyNumbers(TreeNode::ConstIterator iter, int N, T& vector)
114 {
115   for(int i = 0; i < N; ++i)
116   {
117     if( (*iter).second.GetType() == TreeNode::FLOAT)
118     {
119       vector[i] = (*iter).second.GetFloat();
120     }
121     else if( (*iter).second.GetType() == TreeNode::INTEGER )
122     {
123       vector[i] = static_cast<float>((*iter).second.GetInteger());
124     }
125     else
126     {
127       return false;
128     }
129     iter++;
130   }
131
132   return true;
133 }
134
135 inline OptionalVector4 IsVector4(const OptionalChild& node)
136 {
137   OptionalVector4 ret;
138
139   if( node && (TreeNode::ARRAY == (*node).GetType()) && (*node).Size() >= 4 )
140   {
141     Dali::Vector4 v;
142     if( CopyNumbers((*node).CBegin(), 4, v) )
143     {
144       ret = OptionalVector4(v);
145     }
146   }
147
148   return ret;
149 }
150
151 inline OptionalVector3 IsVector3(const OptionalChild& node)
152 {
153   OptionalVector3 ret;
154
155   if( node && (TreeNode::ARRAY == (*node).GetType()) && (*node).Size() >= 3 )
156   {
157     Dali::Vector3 v;
158     if( CopyNumbers((*node).CBegin(), 3, v) )
159     {
160       ret = OptionalVector3(v);
161     }
162   }
163
164   return ret;
165 }
166
167 inline OptionalVector2 IsVector2(const OptionalChild& node)
168 {
169   OptionalVector2 ret;
170
171   if( node && (TreeNode::ARRAY == (*node).GetType()) && (*node).Size() >= 2 )
172   {
173     Dali::Vector2 v;
174     if( CopyNumbers((*node).CBegin(), 2, v) )
175     {
176       ret = OptionalVector2(v);
177     }
178   }
179
180   return ret;
181 }
182
183 inline OptionalMatrix IsMatrix(const OptionalChild &node)
184 {
185   OptionalMatrix ret;
186
187   if( node && (TreeNode::ARRAY == (*node).GetType()) && (*node).Size() >= 16 )
188   {
189     float v[16];
190     if( CopyNumbers((*node).CBegin(), 16, v) )
191     {
192       ret = OptionalMatrix(Dali::Matrix(v));
193     }
194   }
195
196   return ret;
197 }
198
199 inline OptionalMatrix3 IsMatrix3(const OptionalChild& node)
200 {
201   OptionalMatrix3 ret;
202
203   if( node && (TreeNode::ARRAY == (*node).GetType()) && (*node).Size() >= 9 )
204   {
205     float v[9];
206     if( CopyNumbers((*node).CBegin(), 9, v) )
207     {
208       ret = OptionalMatrix3(Dali::Matrix3(v[0], v[1], v[2],
209                                           v[3], v[4], v[5],
210                                           v[6], v[7], v[8] ));
211     }
212   }
213
214   return ret;
215 }
216
217 inline OptionalRect IsRect(const OptionalChild& node)
218 {
219   OptionalRect ret;
220   if(node && (*node).Size())
221   {
222     if((*node).Size() >= 4)
223     {
224       TreeNode::ConstIterator iter((*node).CBegin());
225       int v[4];
226       if( CopyNumbers((*node).CBegin(), 4, v) )
227       {
228         ret = OptionalRect(Dali::Rect<int>(v[0], v[1], v[2], v[3]));
229       }
230     }
231   }
232   return ret;
233 }
234
235 //
236 //
237 //
238 inline OptionalString IsString( const TreeNode& parent, const std::string& childName)
239 {
240   return IsString( IsChild(&parent, childName) );
241 }
242
243 inline OptionalFloat IsFloat( const TreeNode& parent, const std::string& childName)
244 {
245   return IsFloat( IsChild(&parent, childName) );
246 }
247
248 inline OptionalInteger IsInteger( const TreeNode& parent, const std::string& childName)
249 {
250   return IsInteger( IsChild(&parent, childName) );
251 }
252
253 inline OptionalBoolean IsBoolean( const TreeNode& parent, const std::string& childName)
254 {
255   return IsBoolean( IsChild(parent, childName) );
256 }
257
258 inline OptionalVector4 IsVector4(const TreeNode &parent, const std::string& childName)
259 {
260   return IsVector4( IsChild(parent, childName) );
261 }
262
263 inline OptionalVector3 IsVector3(const TreeNode &parent, const std::string& childName)
264 {
265   return IsVector3( IsChild(parent, childName) );
266 }
267
268 inline OptionalVector2 IsVector2(const TreeNode &parent, const std::string& childName)
269 {
270   return IsVector2( IsChild(parent, childName) );
271 }
272
273 inline OptionalMatrix IsMatrix(const TreeNode &parent, const std::string& childName)
274 {
275   return IsMatrix( IsChild(parent, childName) );
276 }
277
278 inline OptionalMatrix3 IsMatrix3(const TreeNode &parent, const std::string& childName)
279 {
280   return IsMatrix3( IsChild(&parent, childName) );
281 }
282
283 inline OptionalRect IsRect(const TreeNode &parent, const std::string& childName)
284 {
285   return IsRect( IsChild(&parent, childName) );
286 }
287
288 //
289 //
290 //
291 inline OptionalString IsString( const TreeNode& node )
292 {
293   return IsString( OptionalChild( node ) );
294 }
295
296 inline OptionalFloat IsFloat( const TreeNode& node )
297 {
298   return IsFloat( OptionalChild( node ) );
299 }
300
301 inline OptionalInteger IsInteger( const TreeNode& node )
302 {
303   return IsInteger( OptionalChild( node ) );
304 }
305
306 inline OptionalBoolean IsBoolean( const TreeNode& node )
307 {
308   return IsBoolean( OptionalChild( node ) );
309 }
310
311 inline OptionalVector4 IsVector4(const TreeNode &node )
312 {
313   return IsVector4( OptionalChild( node ) );
314 }
315
316 inline OptionalVector3 IsVector3(const TreeNode &node )
317 {
318   return IsVector3( OptionalChild( node ) );
319 }
320
321 inline OptionalVector2 IsVector2(const TreeNode &node )
322 {
323   return IsVector2( OptionalChild( node ) );
324 }
325
326 inline OptionalMatrix IsMatrix(const TreeNode &node )
327 {
328   return IsMatrix( OptionalChild( node ) );
329 }
330
331 inline OptionalMatrix3 IsMatrix3(const TreeNode &node )
332 {
333   return IsMatrix3( OptionalChild( node ) );
334 }
335
336 inline OptionalRect IsRect(const TreeNode &node )
337 {
338   return IsRect( OptionalChild( node ) );
339 }
340
341 //
342 //
343 //
344 inline Dali::Vector4 GetVector4(const TreeNode &child)
345 {
346   OptionalVector4 v( IsVector4( OptionalChild( child ) ) );
347   DALI_ASSERT_ALWAYS(v);
348   return *v;
349 }
350
351 inline Dali::Vector3 GetVector3(const TreeNode &child)
352 {
353   OptionalVector3 v( IsVector3( OptionalChild( child ) ) );
354   DALI_ASSERT_ALWAYS(v);
355   return *v;
356 }
357
358 inline Dali::Vector2 GetVector2(const TreeNode &child)
359 {
360   OptionalVector2 v( IsVector2( OptionalChild( child ) ) );
361   DALI_ASSERT_ALWAYS(v);
362   return *v;
363 }
364
365 inline float GetFloat(const TreeNode &child)
366 {
367   OptionalFloat v( IsFloat( OptionalChild( child ) ) );
368   DALI_ASSERT_ALWAYS(v);
369   return *v;
370 }
371
372 inline bool GetBoolean(const TreeNode &child)
373 {
374   OptionalBoolean v( IsBoolean( OptionalChild( child ) ) );
375   DALI_ASSERT_ALWAYS(v);
376   return *v;
377 }
378
379 inline int GetInteger(const TreeNode &child)
380 {
381   OptionalInteger v( IsInteger( OptionalChild( child ) ) );
382   DALI_ASSERT_ALWAYS(v);
383   return *v;
384 }
385
386
387
388 #endif // __DALI_TOOLKIT_INTERNAL_BUILDER_GET_IS_INL__