Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 1 | //===- InputTree.h --------------------------------------------------------===// |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 2 | // |
| 3 | // The MCLinker Project |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 9 | #ifndef MCLD_INPUTTREE_H_ |
| 10 | #define MCLD_INPUTTREE_H_ |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 11 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 12 | #include "mcld/ADT/BinTree.h" |
| 13 | #include "mcld/ADT/TypeTraits.h" |
| 14 | #include "mcld/MC/Input.h" |
| 15 | #include "mcld/Support/Path.h" |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 16 | |
| 17 | #include <string> |
| 18 | |
Shih-wei Liao | 22add6f | 2012-12-15 17:21:00 -0800 | [diff] [blame] | 19 | namespace mcld { |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 20 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 21 | /** \class template<typename Traits, typename Iterator> |
| 22 | * PolicyIterator<mcld::Input> |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 23 | * \brief PolicyIterator<mcld::Input> is a partially specific PolicyIterator |
| 24 | */ |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 25 | template <typename Traits, typename IteratorType> |
| 26 | class PolicyIterator<mcld::Input, Traits, IteratorType> |
| 27 | : public PolicyIteratorBase<Input, Traits, IteratorType> { |
| 28 | public: |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 29 | typedef PolicyIterator<Input, Traits, IteratorType> Self; |
| 30 | typedef PolicyIteratorBase<Input, Traits, IteratorType> Base; |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 31 | typedef PolicyIterator<Input, typename Traits::nonconst_traits, IteratorType> |
| 32 | iterator; |
| 33 | typedef PolicyIterator<Input, typename Traits::const_traits, IteratorType> |
| 34 | const_iterator; |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 35 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 36 | public: |
| 37 | PolicyIterator() : Base() {} |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 38 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 39 | PolicyIterator(const iterator& X) : Base(X.m_pNode) {} |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 40 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 41 | explicit PolicyIterator(NodeBase* X) : Base(X) {} |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 42 | |
| 43 | virtual ~PolicyIterator() {} |
| 44 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 45 | bool isGroup() const { return !Base::hasData() && !Base::isRoot(); } |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 46 | |
| 47 | Self& operator++() { |
| 48 | IteratorType::advance(); |
Shih-wei Liao | 22add6f | 2012-12-15 17:21:00 -0800 | [diff] [blame] | 49 | // skip the Group node |
| 50 | while (isGroup()) |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 51 | IteratorType::advance(); |
| 52 | return *this; |
| 53 | } |
| 54 | |
| 55 | Self operator++(int) { |
| 56 | Self tmp(*this); |
| 57 | IteratorType::advance(); |
Shih-wei Liao | 22add6f | 2012-12-15 17:21:00 -0800 | [diff] [blame] | 58 | // skip the Group node |
| 59 | while (isGroup()) |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 60 | IteratorType::advance(); |
| 61 | return tmp; |
| 62 | } |
| 63 | }; |
| 64 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 65 | template <> |
| 66 | class BinaryTree<Input> : public BinaryTreeBase<Input> { |
| 67 | public: |
| 68 | typedef size_t size_type; |
| 69 | typedef ptrdiff_t difference_type; |
| 70 | typedef Input value_type; |
| 71 | typedef value_type* pointer; |
| 72 | typedef value_type& reference; |
| 73 | typedef const value_type* const_pointer; |
| 74 | typedef const value_type& const_reference; |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 75 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 76 | typedef BinaryTree<Input> Self; |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 77 | typedef TreeIterator<value_type, NonConstTraits<value_type> > iterator; |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 78 | typedef TreeIterator<value_type, ConstTraits<value_type> > const_iterator; |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 79 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 80 | typedef PolicyIterator<value_type, NonConstTraits<value_type>, DFSIterator> |
| 81 | dfs_iterator; |
| 82 | typedef PolicyIterator<value_type, ConstTraits<value_type>, DFSIterator> |
| 83 | const_dfs_iterator; |
| 84 | typedef PolicyIterator<value_type, NonConstTraits<value_type>, BFSIterator> |
| 85 | bfs_iterator; |
| 86 | typedef PolicyIterator<value_type, ConstTraits<value_type>, BFSIterator> |
| 87 | const_bfs_iterator; |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 88 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 89 | protected: |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 90 | typedef Node<value_type> node_type; |
| 91 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 92 | public: |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 93 | // ----- constructors and destructor ----- // |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 94 | BinaryTree() : BinaryTreeBase<Input>() {} |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 95 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 96 | ~BinaryTree() {} |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 97 | |
| 98 | // ----- iterators ----- // |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 99 | bfs_iterator bfs_begin() { |
| 100 | bfs_iterator it = bfs_iterator(BinaryTreeBase<Input>::m_Root.node.left); |
| 101 | if (it.isGroup()) |
| 102 | ++it; |
| 103 | return it; |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 104 | } |
| 105 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 106 | bfs_iterator bfs_end() { |
| 107 | return bfs_iterator(BinaryTreeBase<Input>::m_Root.node.right); |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 108 | } |
| 109 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 110 | const_bfs_iterator bfs_begin() const { |
| 111 | const_bfs_iterator it = |
| 112 | const_bfs_iterator(BinaryTreeBase<Input>::m_Root.node.left); |
| 113 | if (it.isGroup()) |
| 114 | ++it; |
| 115 | return it; |
| 116 | } |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 117 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 118 | const_bfs_iterator bfs_end() const { |
| 119 | return const_bfs_iterator(BinaryTreeBase<Input>::m_Root.node.right); |
| 120 | } |
| 121 | |
| 122 | dfs_iterator dfs_begin() { |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 123 | dfs_iterator it = dfs_iterator(BinaryTreeBase<Input>::m_Root.node.left); |
| 124 | if (it.isGroup()) |
| 125 | ++it; |
| 126 | return it; |
| 127 | } |
| 128 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 129 | dfs_iterator dfs_end() { |
| 130 | return dfs_iterator(BinaryTreeBase<Input>::m_Root.node.right); |
| 131 | } |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 132 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 133 | const_dfs_iterator dfs_begin() const { |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 134 | const_dfs_iterator it = |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 135 | const_dfs_iterator(BinaryTreeBase<Input>::m_Root.node.left); |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 136 | if (it.isGroup()) |
| 137 | ++it; |
| 138 | return it; |
| 139 | } |
| 140 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 141 | const_dfs_iterator dfs_end() const { |
| 142 | return const_dfs_iterator(BinaryTreeBase<Input>::m_Root.node.right); |
| 143 | } |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 144 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 145 | iterator root() { return iterator(&(BinaryTreeBase<Input>::m_Root.node)); } |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 146 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 147 | const_iterator root() const { |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 148 | // FIXME: provide the iterater constructors for constant NodeBase instead of |
| 149 | // using const_cast |
| 150 | return const_iterator( |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 151 | const_cast<NodeBase*>(&BinaryTreeBase<Input>::m_Root.node)); |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 152 | } |
| 153 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 154 | iterator begin() { |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 155 | iterator it = iterator(BinaryTreeBase<Input>::m_Root.node.left); |
| 156 | return it; |
| 157 | } |
| 158 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 159 | iterator end() { return iterator(BinaryTreeBase<Input>::m_Root.node.right); } |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 160 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 161 | const_iterator begin() const { |
| 162 | return const_iterator(BinaryTreeBase<Input>::m_Root.node.left); |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 163 | } |
| 164 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 165 | const_iterator end() const { |
| 166 | return const_iterator(BinaryTreeBase<Input>::m_Root.node.right); |
| 167 | } |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 168 | |
| 169 | // ----- modifiers ----- // |
| 170 | /// join - create a leaf node and merge it in the tree. |
| 171 | // This version of join determines the direction on compilation time. |
| 172 | // @param DIRECT the direction of the connecting edge of the parent node. |
| 173 | // @param position the parent node |
| 174 | // @param value the value being pushed. |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 175 | template <size_t DIRECT> |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 176 | BinaryTree& join(TreeIteratorBase& pPosition, const Input& value) { |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 177 | node_type* node = BinaryTreeBase<Input>::createNode(); |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 178 | node->data = const_cast<Input*>(&value); |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 179 | |
| 180 | if (pPosition.isRoot()) |
| 181 | pPosition.hook<TreeIteratorBase::Leftward>(node); |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 182 | else |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 183 | pPosition.hook<DIRECT>(node); |
| 184 | |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 185 | return *this; |
| 186 | } |
| 187 | |
| 188 | /// merge - merge the tree |
| 189 | // @param DIRECT the direction of the connecting edge of the parent node. |
| 190 | // @param position the parent node |
| 191 | // @param the tree being joined. |
| 192 | // @return the joined tree |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 193 | template <size_t DIRECT> |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 194 | BinaryTree& merge(TreeIteratorBase& pPosition, BinaryTree& pTree) { |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 195 | if (this == &pTree) |
| 196 | return *this; |
| 197 | |
| 198 | if (!pTree.empty()) { |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 199 | pPosition.hook<DIRECT>(pTree.m_Root.node.left); |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 200 | BinaryTreeBase<Input>::m_Root.summon(pTree.BinaryTreeBase<Input>::m_Root); |
Stephen Hines | f7ac0f1 | 2013-05-03 19:09:24 -0700 | [diff] [blame] | 201 | BinaryTreeBase<Input>::m_Root.delegate(pTree.m_Root); |
| 202 | pTree.m_Root.node.left = pTree.m_Root.node.right = &pTree.m_Root.node; |
| 203 | } |
| 204 | return *this; |
| 205 | } |
| 206 | }; |
| 207 | |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 208 | /** \class InputTree |
| 209 | * \brief InputTree is the input tree to contains all inputs from the |
| 210 | * command line. |
| 211 | * |
| 212 | * InputTree, of course, is uncopyable. |
| 213 | * |
| 214 | * @see Input |
| 215 | */ |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 216 | class InputTree : public BinaryTree<Input> { |
| 217 | private: |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 218 | typedef BinaryTree<Input> BinTreeTy; |
| 219 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 220 | public: |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 221 | enum Direction { |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 222 | Inclusive = TreeIteratorBase::Leftward, |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 223 | Positional = TreeIteratorBase::Rightward |
| 224 | }; |
| 225 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 226 | typedef BinaryTree<Input>::iterator iterator; |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 227 | typedef BinaryTree<Input>::const_iterator const_iterator; |
| 228 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 229 | public: |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 230 | /** \class Mover |
| 231 | * \brief Mover provides the interface for moving iterator forward. |
| 232 | * |
| 233 | * Mover is a function object (functor). @ref Mover::move moves |
| 234 | * iterator forward in certain direction. @ref Mover::connect |
| 235 | * connects two nodes of the given iterators togather. |
| 236 | */ |
| 237 | struct Mover { |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 238 | virtual void connect(TreeIteratorBase& pFrom, NodeBase* pTo) const = 0; |
Shih-wei Liao | 67e37f1 | 2012-07-27 03:50:34 -0700 | [diff] [blame] | 239 | virtual void move(TreeIteratorBase& pNode) const = 0; |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 240 | virtual ~Mover() {} |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 241 | }; |
| 242 | |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 243 | /** \class Succeeder |
| 244 | * \brief class Succeeder moves the iterator afterward. |
| 245 | */ |
| 246 | struct Succeeder : public Mover { |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 247 | void connect(TreeIteratorBase& pFrom, NodeBase* pTo) const { |
| 248 | pFrom.hook<Positional>(pTo); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 249 | } |
| 250 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 251 | void move(TreeIteratorBase& pNode) const { pNode.move<Positional>(); } |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 252 | }; |
| 253 | |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 254 | /** \class Includer |
| 255 | * \brief class Includer moves the iterator downward. |
| 256 | */ |
| 257 | struct Includer : public Mover { |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 258 | void connect(TreeIteratorBase& pFrom, NodeBase* pTo) const { |
| 259 | pFrom.hook<Inclusive>(pTo); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 260 | } |
| 261 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 262 | void move(TreeIteratorBase& pNode) const { pNode.move<Inclusive>(); } |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 263 | }; |
| 264 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 265 | public: |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 266 | static Succeeder Afterward; |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 267 | static Includer Downward; |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 268 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 269 | public: |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 270 | using BinTreeTy::merge; |
| 271 | |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 272 | // ----- modify ----- // |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 273 | template <size_t DIRECT> |
Shih-wei Liao | 67e37f1 | 2012-07-27 03:50:34 -0700 | [diff] [blame] | 274 | InputTree& enterGroup(TreeIteratorBase pRoot); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 275 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 276 | template <size_t DIRECT> |
| 277 | InputTree& insert(TreeIteratorBase pRoot, Input& pInput); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 278 | |
Shih-wei Liao | 22add6f | 2012-12-15 17:21:00 -0800 | [diff] [blame] | 279 | InputTree& merge(TreeIteratorBase pRoot, |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 280 | const Mover& pMover, |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 281 | InputTree& pTree); |
| 282 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 283 | InputTree& insert(TreeIteratorBase pRoot, const Mover& pMover, Input& pInput); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 284 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 285 | InputTree& enterGroup(TreeIteratorBase pRoot, const Mover& pMover); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 286 | }; |
| 287 | |
| 288 | bool isGroup(const InputTree::iterator& pos); |
| 289 | bool isGroup(const InputTree::const_iterator& pos); |
| 290 | bool isGroup(const InputTree::dfs_iterator& pos); |
| 291 | bool isGroup(const InputTree::const_dfs_iterator& pos); |
| 292 | bool isGroup(const InputTree::bfs_iterator& pos); |
| 293 | bool isGroup(const InputTree::const_bfs_iterator& pos); |
| 294 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 295 | } // namespace mcld |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 296 | |
| 297 | //===----------------------------------------------------------------------===// |
| 298 | // template member functions |
Shih-wei Liao | 22add6f | 2012-12-15 17:21:00 -0800 | [diff] [blame] | 299 | //===----------------------------------------------------------------------===// |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 300 | template <size_t DIRECT> |
| 301 | mcld::InputTree& mcld::InputTree::enterGroup(mcld::TreeIteratorBase pRoot) { |
Shih-wei Liao | 22add6f | 2012-12-15 17:21:00 -0800 | [diff] [blame] | 302 | BinTreeTy::node_type* node = createNode(); |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 303 | |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 304 | if (pRoot.isRoot()) |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 305 | pRoot.hook<TreeIteratorBase::Leftward>(node); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 306 | else |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 307 | pRoot.hook<DIRECT>(node); |
| 308 | |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 309 | return *this; |
| 310 | } |
| 311 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 312 | template <size_t DIRECT> |
Shih-wei Liao | 67e37f1 | 2012-07-27 03:50:34 -0700 | [diff] [blame] | 313 | mcld::InputTree& mcld::InputTree::insert(mcld::TreeIteratorBase pRoot, |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 314 | mcld::Input& pInput) { |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 315 | BinTreeTy::node_type* node = createNode(); |
Shih-wei Liao | 22add6f | 2012-12-15 17:21:00 -0800 | [diff] [blame] | 316 | node->data = &pInput; |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 317 | |
Zonr Chang | affc150 | 2012-07-16 14:28:23 +0800 | [diff] [blame] | 318 | if (pRoot.isRoot()) |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 319 | pRoot.hook<TreeIteratorBase::Leftward>(node); |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 320 | else |
Stephen Hines | 87f3465 | 2014-02-14 18:00:16 -0800 | [diff] [blame] | 321 | pRoot.hook<DIRECT>(node); |
| 322 | |
Shih-wei Liao | 5460a1f | 2012-03-16 22:41:16 -0700 | [diff] [blame] | 323 | return *this; |
| 324 | } |
| 325 | |
Stephen Hines | 37b74a3 | 2014-11-26 18:48:20 -0800 | [diff] [blame] | 326 | #endif // MCLD_INPUTTREE_H_ |