Reporting dali version on stderr instead of stdout
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / builder / tree-node-manipulator.cpp
1 /*
2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
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 // EXTERNAL INCLUDES
19 #include <cstring>
20 #include <sstream>
21
22 // INTERNAL INCLUDES
23 #include <dali-toolkit/internal/builder/tree-node-manipulator.h>
24
25 #include <dali-toolkit/devel-api/builder/tree-node.h>
26
27 namespace Dali
28 {
29
30 namespace Toolkit
31 {
32
33 namespace Internal
34 {
35
36 namespace
37 {
38
39 void Indent(std::ostream& o, int level, int indentWidth)
40 {
41   for (int i = 0; i < level*indentWidth; ++i)
42   {
43     o << " ";
44   }
45 }
46
47 std::string EscapeQuotes( const char* aString)
48 {
49   std::string escapedString;
50   int length = strlen(aString);
51   escapedString.reserve(length);
52
53   const char* end = aString+length;
54   for( const char* iter = aString; iter != end ; ++iter)
55   {
56     if(*iter != '\"')
57     {
58       escapedString.push_back(*iter);
59     }
60     else
61     {
62       escapedString.append("\\\"");
63     }
64   }
65   return escapedString;
66 }
67
68 } // anonymous namespace
69
70 TreeNodeManipulator::TreeNodeManipulator(TreeNode* node)
71   : mNode(node)
72 {
73 }
74
75 TreeNode* TreeNodeManipulator::NewTreeNode()
76 {
77   return new TreeNode();
78 }
79
80 void TreeNodeManipulator::ShallowCopy(const TreeNode* from, TreeNode* to)
81 {
82   DALI_ASSERT_DEBUG(from);
83   DALI_ASSERT_DEBUG(to);
84
85   if( from )
86   {
87     to->mName         = from->mName;
88     to->mType         = from->mType;
89     to->mSubstituion  = from->mSubstituion;
90     switch(from->mType)
91     {
92       case TreeNode::INTEGER:
93       {
94         to->mIntValue = from->mIntValue;
95         break;
96       }
97       case TreeNode::FLOAT:
98       {
99         to->mFloatValue = from->mFloatValue;
100         break;
101       }
102       case TreeNode::STRING:
103       {
104         to->mStringValue = from->mStringValue;
105         break;
106       }
107       case TreeNode::BOOLEAN:
108       {
109         to->mIntValue = from->mIntValue;
110         break;
111       }
112       case TreeNode::IS_NULL:
113       case TreeNode::OBJECT:
114       case TreeNode::ARRAY:
115       {
116         break;
117       }
118     }
119   }
120
121 }
122
123 void TreeNodeManipulator::MoveNodeStrings(VectorCharIter& start, const VectorCharIter& sentinel)
124 {
125   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
126   if(mNode->mName)
127   {
128     mNode->mName = CopyString(mNode->mName, start, sentinel);
129   }
130
131   if(TreeNode::STRING == mNode->mType)
132   {
133     mNode->mStringValue = CopyString(mNode->mStringValue, start, sentinel);
134   }
135 }
136
137 void TreeNodeManipulator::MoveStrings(VectorCharIter& start, const VectorCharIter& sentinel)
138 {
139   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
140   TreeNodeManipulator modify(mNode);
141   modify.MoveNodeStrings(start, sentinel);
142   RecurseMoveChildStrings(start, sentinel);
143 }
144
145 void TreeNodeManipulator::RecurseMoveChildStrings(VectorCharIter& start, const VectorCharIter& sentinel)
146 {
147   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
148
149   TreeNode* child = mNode->mFirstChild;
150   while(child)
151   {
152     TreeNodeManipulator manipChild(child);
153     manipChild.MoveNodeStrings(start, sentinel);
154     child = child->mNextSibling;
155   }
156
157   child = mNode->mFirstChild;
158   while(child)
159   {
160     TreeNodeManipulator manipChild(child);
161     manipChild.RecurseMoveChildStrings(start, sentinel);
162     child = child->mNextSibling;
163   }
164 }
165
166 void TreeNodeManipulator::RemoveChildren()
167 {
168   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
169
170   CollectNodes collector;
171
172   DepthFirst( mNode, collector );
173
174   for(CollectNodes::iterator iter = collector.nodes.begin(); iter != collector.nodes.end(); ++iter)
175   {
176     if( *iter != mNode)
177     {
178       delete *iter;
179     }
180   }
181
182   mNode->mFirstChild = NULL;
183   mNode->mLastChild  = NULL;
184 }
185
186 TreeNode* TreeNodeManipulator::Copy(const TreeNode& tree, int& numberNodes, int& numberChars)
187 {
188   TreeNode* root = NewTreeNode();
189
190   ShallowCopy(&tree, root);
191
192   if(tree.mName)
193   {
194     numberChars += std::strlen(tree.mName) + 1;
195   }
196
197   if(TreeNode::STRING == tree.mType)
198   {
199     numberChars += std::strlen(tree.mStringValue) + 1;
200   }
201
202   ++numberNodes;
203
204   CopyChildren(&tree, root, numberNodes, numberChars);
205
206   return root;
207 }
208
209 void TreeNodeManipulator::CopyChildren(const TreeNode* from, TreeNode* to, int& numberNodes, int& numberChars)
210 {
211   DALI_ASSERT_DEBUG(from && "Operation on NULL JSON node");
212   DALI_ASSERT_DEBUG(to);
213
214   for( TreeNode::ConstIterator iter = from->CBegin(); iter != from->CEnd(); ++iter)
215   {
216     const TreeNode* child = &((*iter).second);
217     if(child->mName)
218     {
219       numberChars += std::strlen(child->mName) + 1;
220     }
221
222     if(TreeNode::STRING == child->mType)
223     {
224       numberChars += std::strlen(child->mStringValue) + 1;
225     }
226
227     TreeNode* newNode = NewTreeNode();
228
229     ShallowCopy(child, newNode);
230
231     TreeNodeManipulator modify(to);
232
233     modify.AddChild(newNode);
234
235     ++numberNodes;
236
237     CopyChildren(child, newNode, numberNodes, numberChars);
238   }
239 }
240
241 TreeNode *TreeNodeManipulator::AddChild(TreeNode *rhs)
242 {
243   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
244
245   rhs->mParent = mNode;
246   if (mNode->mLastChild)
247   {
248     mNode->mLastChild = mNode->mLastChild->mNextSibling = rhs;
249   }
250   else
251   {
252     mNode->mFirstChild = mNode->mLastChild = rhs;
253   }
254   return rhs;
255 }
256
257 TreeNode::NodeType TreeNodeManipulator::GetType() const
258 {
259   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
260
261   return mNode->GetType();
262 }
263
264 size_t TreeNodeManipulator::Size() const
265 {
266   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
267
268   return mNode->Size();
269 }
270
271 void TreeNodeManipulator::SetType( TreeNode::NodeType type)
272 {
273   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
274
275   if( mNode->mType != type )
276   {
277     mNode->mType = type;
278
279     if( NULL != mNode->mFirstChild )
280     {
281       // value types have no children
282       bool removeChildren = ! (TreeNode::OBJECT == type || TreeNode::ARRAY == type);
283
284       // ie if swapping array for object
285       removeChildren = (removeChildren == true) ? true : type != mNode->mType;
286
287       // so remove any children
288       if( removeChildren && NULL != mNode->mFirstChild)
289       {
290         RemoveChildren();
291       }
292     }
293   }
294 }
295
296 void TreeNodeManipulator::SetName( const char* name )
297 {
298   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
299   mNode->mName = name;
300 }
301
302 void TreeNodeManipulator::SetSubstitution( bool b )
303 {
304   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
305   mNode->mSubstituion = b;
306 }
307
308 TreeNode* TreeNodeManipulator::GetParent() const
309 {
310   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
311   return NULL == mNode ? NULL : mNode->mParent;
312 }
313
314 const TreeNode* TreeNodeManipulator::GetChild(const std::string& name) const
315 {
316   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
317   return NULL == mNode ? NULL : mNode->GetChild(name);
318 }
319
320 void TreeNodeManipulator::SetString( const char* string )
321 {
322   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
323   SetType(TreeNode::STRING);
324   mNode->mStringValue = string;
325 }
326
327 void TreeNodeManipulator::SetInteger( int i )
328 {
329   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
330   SetType(TreeNode::INTEGER);
331   mNode->mIntValue = i;
332 }
333
334 void TreeNodeManipulator::SetFloat( float f )
335 {
336   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
337   SetType(TreeNode::FLOAT);
338   mNode->mFloatValue = f;
339 }
340
341 void TreeNodeManipulator::SetBoolean( bool b )
342 {
343   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
344   SetType(TreeNode::BOOLEAN);
345   mNode->mIntValue = b == true ? 1 : 0;
346 }
347
348 void TreeNodeManipulator::Write(std::ostream& output, int indent) const
349 {
350   DALI_ASSERT_DEBUG(mNode && "Operation on NULL JSON node");
351   DoWrite(mNode, output, 0, indent, false);
352 }
353
354 void TreeNodeManipulator::DoWrite(const TreeNode *value, std::ostream& output, int level, int indentWidth, bool groupChildren) const
355 {
356   DALI_ASSERT_DEBUG(value && "Operation on NULL JSON node");
357
358   if(!groupChildren)
359   {
360     Indent(output, level, indentWidth);
361   }
362
363   if (value->GetName())
364   {
365     output << "\"" << value->GetName() << "\":";
366   }
367
368   switch(value->GetType())
369   {
370     case TreeNode::IS_NULL:
371     {
372       output << "null";
373       if(NULL != value->mNextSibling)
374       {
375         output << ", ";
376       }
377       if( !groupChildren )
378       {
379         output << std::endl;
380       }
381       break;
382     }
383     case TreeNode::OBJECT:
384     case TreeNode::ARRAY:
385     {
386       bool groupMyChildren = false;
387
388       if( TreeNode::ARRAY == value->GetType() &&
389           ( TreeNode::INTEGER == value->mFirstChild->GetType() ||
390             TreeNode::FLOAT   == value->mFirstChild->GetType() ) )
391       {
392         groupMyChildren = true;
393       }
394
395       if( value->GetType() == TreeNode::OBJECT)
396       {
397         output << std::endl;
398         Indent(output, level, indentWidth);
399         output << "{";
400       }
401       else
402       {
403         if( !groupMyChildren )
404         {
405           output << std::endl;
406           Indent(output, level, indentWidth);
407         }
408         output << "[";
409       }
410
411       if( groupMyChildren )
412       {
413         output << " ";
414       }
415       else
416       {
417         output << std::endl;
418       }
419
420       for (TreeNode::ConstIterator it = value->CBegin(); it != value->CEnd(); ++it)
421       {
422         DoWrite( &((*it).second), output, level+1, indentWidth, groupMyChildren );
423       }
424
425       if( !groupMyChildren )
426       {
427         Indent(output, level, indentWidth);
428       }
429
430       if( value->GetType() == TreeNode::OBJECT )
431       {
432         output << "}";
433       }
434       else
435       {
436         output << "]";
437       }
438
439       if( NULL != value->mNextSibling )
440       {
441         output << ",";
442       }
443
444       if( !groupChildren )
445       {
446         output << std::endl;
447       }
448
449       groupChildren = false;
450       break;
451     }
452     case TreeNode::STRING:
453     {
454       std::string escapedString = EscapeQuotes(value->GetString());
455       output << "\"" << escapedString << "\"";
456       if(NULL != value->mNextSibling)
457       {
458         output << ",";
459       }
460
461       if( groupChildren )
462       {
463         output << " ";
464       }
465       else
466       {
467         output << std::endl;
468       }
469       break;
470     }
471     case TreeNode::INTEGER:
472     {
473       output << value->GetInteger();
474       if(NULL != value->mNextSibling)
475       {
476         output << ",";
477       }
478
479       if( groupChildren )
480       {
481         output << " ";
482       }
483       else
484       {
485         output << std::endl;
486       }
487       break;
488     }
489     case TreeNode::FLOAT:
490     {
491       output.setf( std::ios::floatfield );
492       output << value->GetFloat();
493       output.unsetf( std::ios::floatfield );
494       if(NULL != value->mNextSibling)
495       {
496         output << ",";
497       }
498
499       if( groupChildren )
500       {
501         output << " ";
502       }
503       else
504       {
505         output << std::endl;
506       }
507       break;
508     }
509     case TreeNode::BOOLEAN:
510     {
511       if( value->GetInteger() )
512       {
513         output << "true";
514       }
515       else
516       {
517         output << "false";
518       }
519
520       if(NULL != value->mNextSibling)
521       {
522         output << ",";
523       }
524
525       if( groupChildren )
526       {
527         output << " ";
528       }
529       else
530       {
531         output << std::endl;
532       }
533
534       break;
535     }
536   } // switch
537 } // DoWrite
538
539
540 const TreeNode* FindIt(const std::string& childName, const TreeNode* node)
541 {
542   DALI_ASSERT_DEBUG(node);
543
544   const TreeNode* found = NULL;
545
546   if( node )
547   {
548     if( NULL != (found = node->GetChild(childName)) )
549     {
550       return found;
551     }
552     else
553     {
554       for(TreeNode::ConstIterator iter = node->CBegin(); iter != node->CEnd(); ++iter)
555       {
556         if( NULL != (found = FindIt(childName, &((*iter).second)) ) )
557         {
558           return found;
559         }
560       }
561     }
562   }
563   return found;
564 }
565
566 char *CopyString( const char *fromString, VectorCharIter& iter, const VectorCharIter& sentinel)
567 {
568   DALI_ASSERT_DEBUG(fromString);
569   DALI_ASSERT_DEBUG(iter != sentinel);
570
571   char *start= &(*iter);
572   const char *ptr = fromString;
573
574   if(ptr)
575   {
576     while(*ptr != 0)
577     {
578       DALI_ASSERT_DEBUG(iter != sentinel);
579       *iter++ = *ptr++;
580     }
581
582     *iter++ = 0;
583   }
584   return start;
585 }
586
587
588 } // namespace internal
589
590 } // namespace Toolkit
591
592 } // namespace Dali