Mercurial > hg > Members > tatsuki > bench > jungle-core
annotate src/main/java/jp/ac/u_ryukyu/ie/cr/shoshi/jungle/traverser/InterfaceTraverser.java @ 154:b8cef4b640a3
update index for commit
| author | one |
|---|---|
| date | Wed, 26 Nov 2014 06:23:07 +0900 |
| parents | 20af7f25ef32 |
| children | f98f2704b154 6b4aab79910d |
| rev | line source |
|---|---|
| 97 | 1 package jp.ac.u_ryukyu.ie.cr.shoshi.jungle.traverser; |
| 2 | |
| 98 | 3 import java.util.Iterator; |
| 4 | |
| 104 | 5 import fj.data.List; |
| 141 | 6 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.NulIterator; |
| 97 | 7 import jp.ac.u_ryukyu.ie.cr.shoshi.jungle.store.impl.TreeNode; |
| 99 | 8 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.PathNodeIterator; |
| 110 | 9 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.query.Query; |
| 151 | 10 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.Index; |
| 134 | 11 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.IndexManager; |
| 153 | 12 import jp.ac.u_ryukyu.ie.cr.tatsuki.jungle.store.index.ParentIndex; |
| 97 | 13 |
| 100 | 14 public class InterfaceTraverser { |
| 124 | 15 |
| 139 | 16 TreeNode node; |
| 151 | 17 Index index; |
| 153 | 18 ParentIndex parentIndex; |
| 19 boolean parentUpdateFlag; | |
| 139 | 20 IndexManager indexManager; |
| 154 | 21 boolean useIndex; |
| 139 | 22 |
| 154 | 23 public InterfaceTraverser(TreeNode root, IndexManager indexManager, boolean indexFlag) { |
| 24 this(root, new Index(), new ParentIndex(), indexManager, indexFlag); | |
| 25 } | |
| 26 | |
| 27 public InterfaceTraverser(TreeNode root, Index index, ParentIndex parentIndex, IndexManager indexManager, | |
| 28 boolean useIndex) { | |
| 29 this.node = root; | |
| 139 | 30 this.index = index; |
| 31 this.indexManager = indexManager; | |
| 153 | 32 this.parentIndex = parentIndex; |
| 33 if (parentIndex.isEmpty()) | |
| 34 parentUpdateFlag = true; | |
| 35 else | |
| 36 parentUpdateFlag = false; | |
| 154 | 37 this.useIndex = useIndex; |
| 139 | 38 } |
| 39 | |
| 151 | 40 public Index getIndex() { |
| 139 | 41 return index; |
| 42 } | |
| 127 | 43 |
| 153 | 44 public void commit() { |
| 45 parentUpdateFlag = false; | |
| 46 indexManager.commit(index, parentIndex); | |
| 47 } | |
| 48 | |
| 49 public ParentIndex getParentIndex() { | |
| 50 return parentIndex; | |
| 51 } | |
| 52 | |
| 151 | 53 public void setIndex(Index index) { |
| 139 | 54 this.index = index; |
| 55 } | |
| 127 | 56 |
| 154 | 57 public void createIndex() { |
| 153 | 58 |
| 59 final PathNodeIterator itNode = new PathNodeIterator(node); | |
| 154 | 60 for (; itNode.hasNext();) { |
| 61 TreeNode targetNode = itNode.next(); | |
| 62 if (parentUpdateFlag) | |
| 63 parentIndex = parentIndex.set(targetNode); | |
| 64 List<String> keys = targetNode.getAttributes().getKeys(); | |
| 65 for (String key : keys) { | |
| 66 String value = targetNode.getAttributes().getString(key); | |
| 67 if (value != null) | |
| 68 index = index.set(key, value, targetNode); | |
| 153 | 69 } |
| 154 | 70 } |
| 153 | 71 } |
| 72 | |
| 139 | 73 /** |
| 74 * subTree以下のNodeに対してKey,Valueのペアでindexを使って探索を行う | |
| 75 * | |
| 76 * @param query | |
| 77 * @param subTree | |
| 78 * @param key | |
| 79 * @param searchValue | |
| 80 * @return | |
| 81 */ | |
| 153 | 82 public Iterator<TreeNode> findInSubTree(Query query, TreeNode subTree, String key, String searchValue) { |
| 139 | 83 /* |
| 84 * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、 | |
| 85 * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す | |
| 86 */ | |
| 153 | 87 List<TreeNode> nodeList = index.get(key, searchValue); |
| 154 | 88 if (nodeList != null && useIndex) { |
| 139 | 89 |
| 153 | 90 if (nodeList.isEmpty()) |
| 91 return new NulIterator<TreeNode>();// 空のIteratorを返す | |
| 137 | 92 |
| 153 | 93 // ここでNode以下にあるか調べる |
| 94 List<TreeNode> filteredList = List.nil(); | |
| 139 | 95 |
| 153 | 96 for (TreeNode targetNode : nodeList) { |
| 97 TreeNode parent = targetNode; | |
| 98 while (parent != null) { | |
| 99 parent = parentIndex.get(parent); | |
| 100 if (parent.equals(subTree)) | |
| 101 filteredList = filteredList.cons(targetNode); | |
| 102 } | |
| 141 | 103 } |
| 104 | |
| 105 return filteredList.iterator(); | |
| 139 | 106 |
| 107 } else { | |
| 141 | 108 final PathNodeIterator itNode = new PathNodeIterator(subTree); |
| 153 | 109 return new Iterator<TreeNode>() { |
| 139 | 110 |
| 153 | 111 private TreeNode matchNode = nextmatch(itNode); |
| 139 | 112 |
| 153 | 113 private TreeNode nextmatch(PathNodeIterator itNode) { |
| 127 | 114 |
| 139 | 115 for (; itNode.hasNext();) { |
| 153 | 116 TreeNode targetNode = itNode.next(); |
| 117 if (query.condition(targetNode)) | |
| 118 return targetNode; | |
| 139 | 119 } |
| 120 return null; | |
| 121 } | |
| 125 | 122 |
| 139 | 123 @Override |
| 124 public boolean hasNext() { | |
| 153 | 125 if (matchNode == null) { |
| 139 | 126 return false; |
| 127 } | |
| 128 return true; | |
| 129 } | |
| 130 | |
| 131 @Override | |
| 153 | 132 public TreeNode next() { |
| 133 TreeNode currentNode = matchNode; | |
| 134 matchNode = nextmatch(itNode); | |
| 135 return currentNode; | |
| 139 | 136 } |
| 137 | |
| 138 @Override | |
| 139 public void remove() { | |
| 140 } | |
| 141 | |
| 142 }; | |
| 137 | 143 } |
| 139 | 144 } |
| 137 | 145 |
| 139 | 146 /** |
| 147 * subTree以下のNodeに対してKeyに対応する値をindexを使って探索する | |
| 148 * | |
| 149 * @param query | |
| 150 * @param subTree | |
| 151 * @param key | |
| 152 * @param searchValue | |
| 153 * @return | |
| 154 */ | |
| 153 | 155 public Iterator<TreeNode> findInSubTreeAllValue(Query query, TreeNode subTree, String key) { |
| 139 | 156 /* |
| 157 * indexからinnerIndexを取得 取得したinnerIndexが保有するKeyを取得 | |
| 158 * そのKeyを保有するNodeとNodeのPathを取得する | |
| 159 * indexを使って取ってきたNodeのPathと、subTreeのPathを先頭から１つずつ比較し、 | |
| 160 * indexから取ってきたNodeのPathが一致した場合、そのNodeを返す | |
| 137 | 161 */ |
| 153 | 162 Iterator<TreeNode> NodeIterator = index.getAll(key); |
| 154 | 163 if (NodeIterator != null && useIndex) { |
| 153 | 164 List<TreeNode> filteredList = List.nil(); |
| 165 for (; NodeIterator.hasNext();) { | |
| 166 TreeNode targetNode = NodeIterator.next(); | |
| 167 TreeNode parent = targetNode; | |
| 168 while (parent != null) { | |
| 169 parent = parentIndex.get(parent); | |
| 170 if (parent.equals(subTree)) | |
| 171 filteredList = filteredList.cons(targetNode); | |
|
143
afbe19c98f53
change Index form TreeMap<String,TreeMap<String<List<Pair<TreeNode,NodePath>>>> → TreeMap<String,TreeMap<String<List<NodePath>>>
one
parents:
141
diff
changeset
|
172 } |
| 139 | 173 } |
| 174 return filteredList.iterator(); | |
| 137 | 175 |
| 139 | 176 } else { |
| 153 | 177 |
| 141 | 178 final PathNodeIterator itNode = new PathNodeIterator(subTree); |
| 153 | 179 return new Iterator<TreeNode>() { |
| 139 | 180 |
| 153 | 181 private TreeNode matchPair = nextmatch(itNode); |
| 139 | 182 |
| 153 | 183 private TreeNode nextmatch(PathNodeIterator itNode) { |
| 137 | 184 |
| 139 | 185 for (; itNode.hasNext();) { |
| 153 | 186 TreeNode targetNode = itNode.next(); |
| 187 if (query.condition(targetNode)) | |
| 188 return targetNode; | |
| 139 | 189 } |
| 190 return null; | |
| 191 } | |
| 192 | |
| 193 @Override | |
| 194 public boolean hasNext() { | |
| 195 if (matchPair == null) { | |
| 196 return false; | |
| 197 } | |
| 198 return true; | |
| 199 } | |
| 124 | 200 |
| 139 | 201 @Override |
| 153 | 202 public TreeNode next() { |
| 203 TreeNode currentNode = matchPair; | |
| 139 | 204 matchPair = nextmatch(itNode); |
| 153 | 205 return currentNode; |
| 206 } | |
| 207 | |
| 208 @Override | |
| 209 public void remove() { | |
| 210 } | |
| 211 | |
| 212 }; | |
| 213 } | |
| 214 } | |
| 215 | |
| 216 public Iterator<TreeNode> find(Query query, String key, String searchValue) { | |
| 217 | |
| 218 List<TreeNode> nodeList = index.get(key, searchValue); | |
| 154 | 219 if (nodeList != null && useIndex) { |
| 153 | 220 return nodeList.iterator(); |
| 221 } else { | |
| 222 | |
| 223 final PathNodeIterator itNode = new PathNodeIterator(node); | |
| 224 return new Iterator<TreeNode>() { | |
| 225 | |
| 226 private TreeNode matchNode = nextmatch(itNode); | |
| 227 | |
| 228 private TreeNode nextmatch(PathNodeIterator itNode) { | |
| 229 | |
| 230 for (; itNode.hasNext();) { | |
| 231 TreeNode targetNode = itNode.next(); | |
| 232 String value = targetNode.getAttributes().getString(key); | |
| 154 | 233 if (useIndex) { |
| 153 | 234 if (value != null) |
| 235 index = index.set(key, value, targetNode); | |
| 236 } | |
| 237 if (parentUpdateFlag) | |
| 238 parentIndex = parentIndex.set(targetNode); | |
| 239 if (query.condition(targetNode)) | |
| 240 return targetNode; | |
| 241 } | |
| 154 | 242 if (useIndex || parentUpdateFlag) |
| 243 commit(); | |
| 153 | 244 return null; |
| 245 } | |
| 246 | |
| 247 @Override | |
| 248 public boolean hasNext() { | |
| 249 if (matchNode == null) { | |
| 250 return false; | |
| 251 } | |
| 252 return true; | |
| 253 } | |
| 254 | |
| 255 @Override | |
| 256 public TreeNode next() { | |
| 257 TreeNode currentPair = matchNode; | |
| 258 matchNode = nextmatch(itNode); | |
| 139 | 259 return currentPair; |
| 260 } | |
| 261 | |
| 262 @Override | |
| 263 public void remove() { | |
| 264 } | |
| 265 | |
| 266 }; | |
| 267 } | |
| 268 } | |
| 269 | |
| 153 | 270 public Iterator<TreeNode> findAll(Query query, String key) { |
| 139 | 271 |
| 153 | 272 Iterator<TreeNode> nodeList = index.getAll(key); |
| 154 | 273 if (nodeList != null && useIndex) { |
| 139 | 274 |
| 153 | 275 return nodeList; |
| 139 | 276 |
| 277 } else { | |
| 153 | 278 |
| 279 final PathNodeIterator itNode = new PathNodeIterator(node); | |
| 280 return new Iterator<TreeNode>() { | |
| 137 | 281 |
| 153 | 282 private TreeNode matchNode = nextmatch(itNode); |
| 139 | 283 |
| 153 | 284 private TreeNode nextmatch(PathNodeIterator itNode) { |
| 139 | 285 |
| 286 for (; itNode.hasNext();) { | |
| 153 | 287 TreeNode targetNode = itNode.next(); |
| 288 String value = targetNode.getAttributes().getString(key); | |
| 154 | 289 if (useIndex) { |
| 153 | 290 if (value != null) |
| 291 index = index.set(key, value, targetNode); | |
| 137 | 292 } |
| 153 | 293 if (parentUpdateFlag) |
| 294 parentIndex = parentIndex.set(targetNode); | |
| 295 if (query.condition(targetNode)) | |
| 296 return targetNode; | |
| 139 | 297 } |
| 154 | 298 if (useIndex || parentUpdateFlag) |
| 299 commit(); | |
| 139 | 300 return null; |
| 301 } | |
| 136 | 302 |
| 139 | 303 @Override |
| 304 public boolean hasNext() { | |
| 153 | 305 if (matchNode == null) { |
| 139 | 306 return false; |
| 307 } | |
| 308 return true; | |
| 309 } | |
| 136 | 310 |
| 139 | 311 @Override |
| 153 | 312 public TreeNode next() { |
| 313 TreeNode currentPair = matchNode; | |
| 314 matchNode = nextmatch(itNode); | |
| 139 | 315 return currentPair; |
| 316 } | |
| 317 | |
| 318 @Override | |
| 319 public void remove() { | |
| 320 } | |
| 321 | |
| 322 }; | |
| 137 | 323 } |
| 139 | 324 } |
| 97 | 325 } |