dali-toolkit/devel-api/builder/tree-node.h

   1 #ifndef __DALI_SCRIPT_TREE_NODE_H__
   2 #define __DALI_SCRIPT_TREE_NODE_H__
   3
   4 /*
   5  * Copyright (c) 2015 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__