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