Add 'ExclusiveArch: armv7l' limit build to arm architecture
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / public-api / builder / tree-node.h
1 #ifndef __DALI_SCRIPT_TREE_NODE_H__
2 #define __DALI_SCRIPT_TREE_NODE_H__
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 #include <utility> // pair
21 #include <iterator>
22 #include <vector>
23
24 // INTERNAL INCLUDES
25 #include <dali/public-api/common/dali-common.h>
26
27 namespace Dali DALI_IMPORT_API
28 {
29
30 namespace Toolkit
31 {
32
33 namespace Internal DALI_INTERNAL
34 {
35
36 class TreeNodeManipulator;
37
38 } // namespace Internal
39
40
41 /*
42  * TreeNode describes a tree of nodes.
43  * TreeNode does not own its string data which is held by a container eg JsonParser
44  * Modification operations should be done through a container.
45  */
46 class TreeNode
47 {
48 public:
49   /*
50    * enum typedef describing the node type
51    */
52   enum NodeType
53   {
54     IS_NULL,
55     OBJECT,
56     ARRAY,
57     STRING,
58     INTEGER,
59     FLOAT,
60     BOOLEAN,
61   };
62
63   /*
64    * Non virtual destructor; this class should not be inherited from.
65    */
66   ~TreeNode();
67
68   typedef std::pair<const char*, const TreeNode&> KeyNodePair;
69
70   /*
71    * Iterator to iterate through children
72    */
73   class ConstIterator
74   {
75   public:
76     typedef KeyNodePair          value_type;
77     typedef KeyNodePair          *pointer;
78     typedef const KeyNodePair    *const_pointer;
79     typedef KeyNodePair          &reference;
80     typedef const KeyNodePair    &const_reference;
81     typedef size_t               size_type;
82     typedef std::ptrdiff_t       difference_type;
83     typedef std::forward_iterator_tag iterator_category;
84
85     /*
86      * constructor
87      */
88     explicit ConstIterator(TreeNode* v);
89
90     /*
91      * pre increment
92      */
93     ConstIterator& operator ++();
94
95     /*
96      * post increment
97      */
98     ConstIterator operator ++(int);
99
100     /*
101      * != test
102      */
103     bool operator!=( const ConstIterator& rhs ) const;
104
105     /*
106      * pointer semantics
107      */
108     KeyNodePair operator*();
109
110     /*
111      * pointer semantics
112      */
113     KeyNodePair operator->();
114   private:
115     TreeNode* mNode;
116   };
117
118   /*
119    * Iterate begin() over the nodes children
120    * @return a const interator
121    */
122   ConstIterator CBegin() const;
123
124   /*
125    * Iterate end()
126    * @return a const interator
127    */
128   ConstIterator CEnd() const;
129
130   /*
131    * Size (number of children)
132    * @return The number of children
133    */
134   size_t Size() const;
135
136   /*
137    * Count (the number of children of a sub child node)
138    * @param childName The name of the child to find
139    * @return the number of children in the found child
140    */
141   size_t Count(const std::string& childName) const;
142
143   /*
144    * Get the nodes name
145    * @return The nodes name
146    */
147   const char* GetName() const;
148
149   /*
150    * Gets the nodes type
151    * @return The nodes type
152    */
153   NodeType GetType() const;
154
155   /*
156    * Gets the nodes string value
157    * Only valid if the type == TreeNode::STRING
158    * @return The string value
159    */
160   const char* GetString() const;
161
162   /*
163    * Gets the nodes float value
164    * Only valid if the type == TreeNode::FLOAT
165    * @return The float value
166    */
167   float GetFloat() const;
168
169   /*
170    * Gets the nodes integer value
171    * Only valid if the type == TreeNode::INTEGER
172    * @return The integer value
173    */
174   int GetInteger() const;
175
176   /*
177    * Gets the nodes boolean value
178    * Only valid if the type == TreeNode::BOOLEAN
179    * @return The boolean value
180    */
181   bool GetBoolean() const;
182
183   /*
184    * Gets the substituion flag
185    * Only valid if the type == TreeNode::STRING
186    * @return The substitution flag
187    */
188   bool HasSubstitution() const;
189
190   /*
191    * Gets a child of the node
192    * @param name The name of the child
193    * @return The child if found, else NULL
194    */
195   const TreeNode* GetChild(const std::string& name) const;
196
197   /*
198    * Recursively search for a child of the node
199    * @param name The name of the child
200    * @return The child if found, else NULL
201    */
202   const TreeNode* Find(const std::string& name) const;
203
204 private:
205   friend class Internal::TreeNodeManipulator;
206
207   /*
208    * Constructor
209    */
210   TreeNode();
211
212   // non copyable or assignable
213   TreeNode(TreeNode &);
214   TreeNode& operator=(const TreeNode&);
215
216   const char* mName;                   ///< The nodes name (if any)
217
218   TreeNode* mParent;                   ///< The nodes parent
219   TreeNode* mNextSibling;              ///< The nodes next sibling
220   TreeNode* mFirstChild;               ///< The nodes first child
221   TreeNode* mLastChild;                ///< The nodes last child
222
223   union
224   {
225     const char* mStringValue;          ///< The node string value
226     int mIntValue;                     ///< The node integer value
227     float mFloatValue;                 ///< The node float value
228   };
229
230   NodeType mType;                      ///< The nodes type
231   bool mSubstituion;                   ///< String substitution flag
232
233 };
234
235 } // namespace Toolkit
236
237 } // namespace Dali
238
239 #endif // __DALI_SCRIPT_TREE_NODE_H__