001 package org.maltparser.core.syntaxgraph.node;
002
003
004 import java.util.NoSuchElementException;
005 import java.util.Set;
006 import java.util.SortedSet;
007 import java.util.TreeSet;
008
009 import org.maltparser.core.exception.MaltChainedException;
010 import org.maltparser.core.helper.SystemLogger;
011 import org.maltparser.core.symbol.SymbolTable;
012 import org.maltparser.core.syntaxgraph.LabelSet;
013 import org.maltparser.core.syntaxgraph.SyntaxGraphException;
014 import org.maltparser.core.syntaxgraph.TokenStructure;
015 import org.maltparser.core.syntaxgraph.edge.Edge;
016 import org.maltparser.core.syntaxgraph.headrules.Direction;
017 import org.maltparser.core.syntaxgraph.headrules.HeadRules;
018
019
020 public class Root extends GraphNode implements DependencyNode, PhraseStructureNode, NonTerminalNode {
021 protected final SortedSet<DependencyNode> leftDependents;
022 protected final SortedSet<DependencyNode> rightDependents;
023 protected final SortedSet<PhraseStructureNode> children;
024
025 /**
026 * a reference to a node where the node is part of a component. If the node is unconnected it will reference to it self.
027 */
028 protected DependencyNode component;
029 protected int rank;
030 public Root() throws MaltChainedException {
031 super();
032 leftDependents = new TreeSet<DependencyNode>();
033 rightDependents = new TreeSet<DependencyNode>();
034 children = new TreeSet<PhraseStructureNode>();
035 clear();
036 }
037
038 public void addIncomingEdge(Edge in) throws MaltChainedException {
039 throw new SyntaxGraphException("It is not allowed for a root node to have an incoming edge");
040 }
041
042 public void removeIncomingEdge(Edge in) { }
043
044 public void addOutgoingEdge(Edge out) throws MaltChainedException {
045 super.addOutgoingEdge(out);
046 if (out.getTarget() != null) {
047 if (out.getType() == Edge.DEPENDENCY_EDGE && out.getTarget() instanceof DependencyNode) {
048 Node dependent = out.getTarget();
049 if (compareTo(dependent) > 0) {
050 leftDependents.add((DependencyNode)dependent);
051 } else if (compareTo(dependent) < 0) {
052 rightDependents.add((DependencyNode)dependent);
053 }
054 } else if (out.getType() == Edge.PHRASE_STRUCTURE_EDGE && out.getTarget() instanceof PhraseStructureNode) {
055 children.add((PhraseStructureNode)out.getTarget());
056 }
057 }
058 }
059
060 public void removeOutgoingEdge(Edge out) throws MaltChainedException {
061 super.removeOutgoingEdge(out);
062 if (out.getTarget() != null) {
063 if (out.getType() == Edge.DEPENDENCY_EDGE && out.getTarget() instanceof DependencyNode) {
064 Node dependent = out.getTarget();
065 if (compareTo(dependent) > 0) {
066 leftDependents.remove((DependencyNode)dependent);
067 } else if (compareTo(dependent) < 0) {
068 rightDependents.remove((DependencyNode)dependent);
069 }
070 } else if (out.getType() == Edge.PHRASE_STRUCTURE_EDGE && out.getTarget() instanceof PhraseStructureNode) {
071 children.remove((PhraseStructureNode)out.getTarget());
072 }
073 }
074 }
075
076 public DependencyNode getAncestor() throws MaltChainedException {
077 return this;
078 }
079
080 public DependencyNode getProperAncestor() throws MaltChainedException {
081 return null;
082 }
083
084 public int getRank() {
085 return rank;
086 }
087
088 public void setRank(int r) {
089 this.rank = r;
090 }
091
092 public DependencyNode findComponent() {
093 return findComponent(this);
094 }
095
096 private DependencyNode findComponent(DependencyNode x) {
097 if (x != x.getComponent()) {
098 x.setComponent(findComponent(x.getComponent()));
099 }
100 return x.getComponent();
101 }
102
103 public DependencyNode getComponent() {
104 return component;
105 }
106
107 public void setComponent(DependencyNode x) {
108 this.component = x;
109 }
110
111
112 public boolean isContinuous() {
113 return true;
114 }
115
116 public boolean isContinuousExcludeTerminalsAttachToRoot() {
117 return true;
118 }
119
120 public PhraseStructureNode getParent() {
121 return null;
122 }
123
124 public Edge getParentEdge() throws MaltChainedException {
125 return null;
126 }
127
128 public String getParentEdgeLabelSymbol(SymbolTable table) throws MaltChainedException {
129 return null;
130 }
131
132 public int getParentEdgeLabelCode(SymbolTable table) throws MaltChainedException {
133 return -1;
134 }
135
136 public boolean hasParentEdgeLabel(SymbolTable table) throws MaltChainedException {
137 return false;
138 }
139
140 public SortedSet<PhraseStructureNode> getChildren() {
141 return new TreeSet<PhraseStructureNode>(children);
142 }
143
144 public PhraseStructureNode getChild(int index) {
145 if (index >= 0 && index < children.size()) {
146 return children.toArray(new PhraseStructureNode[children.size()])[index];
147 }
148 return null;
149 }
150
151 public PhraseStructureNode getLeftChild() {
152 for (PhraseStructureNode node : children) {
153 return node;
154 }
155 return null;
156 }
157
158 public PhraseStructureNode getRightChild() {
159 int n = children.size();
160 int i = 1;
161 for (PhraseStructureNode node : children) {
162 if (i == n) {
163 return node;
164 }
165 }
166 return null;
167 }
168
169 public int nChildren() {
170 return children.size();
171 }
172
173 public boolean hasNonTerminalChildren() {
174 for (PhraseStructureNode node : children) {
175 if (node instanceof NonTerminal) {
176 return true;
177 }
178 }
179 return false;
180 }
181
182 public boolean hasTerminalChildren() {
183 for (PhraseStructureNode node : children) {
184 if (node instanceof Token) {
185 return true;
186 }
187 }
188 return false;
189 }
190
191 public int getHeight() {
192 int max = -1;
193 for (PhraseStructureNode node : children) {
194 if (node instanceof Token) {
195 if (max < 0) {
196 max = 0;
197 }
198 } else {
199 int nodeheight = ((NonTerminalNode)node).getHeight();
200 if (max < nodeheight) {
201 max = nodeheight;
202 }
203 }
204 }
205 return max + 1;
206 }
207
208 public TokenNode getLexicalHead(HeadRules headRules) throws MaltChainedException {
209 return identifyHead(headRules);
210 }
211
212 public PhraseStructureNode getHeadChild(HeadRules headRules) throws MaltChainedException {
213 return identifyHeadChild(headRules);
214 }
215
216 public TokenNode getLexicalHead() throws MaltChainedException {
217 return identifyHead(null);
218 }
219
220 public PhraseStructureNode getHeadChild() throws MaltChainedException {
221 return identifyHeadChild(null);
222 }
223
224 private PhraseStructureNode identifyHeadChild(HeadRules headRules) throws MaltChainedException {
225 PhraseStructureNode headChild = (headRules == null)?null:headRules.getHeadChild(this);
226 if (headChild == null) {
227 Direction direction = (headRules == null)?Direction.LEFT:headRules.getDefaultDirection(this);
228 if (direction == Direction.LEFT) {
229 if ((headChild = leftmostTerminalChild()) == null) {
230 headChild = leftmostNonTerminalChild();
231 }
232 } else {
233 if ((headChild = rightmostTerminalChild()) == null) {
234 headChild = rightmostNonTerminalChild();
235 }
236 }
237 }
238 return headChild;
239 }
240
241 public TokenNode identifyHead(HeadRules headRules) throws MaltChainedException {
242 PhraseStructureNode headChild = identifyHeadChild(headRules);
243 TokenNode lexicalHead = null;
244 if (headChild instanceof NonTerminalNode) {
245 lexicalHead = ((NonTerminalNode)headChild).identifyHead(headRules);
246 } else if (headChild instanceof TokenNode) {
247 lexicalHead = (TokenNode)headChild;
248 }
249 for (PhraseStructureNode node : children) {
250 if (node != headChild && node instanceof NonTerminalNode) {
251 ((NonTerminalNode)node).identifyHead(headRules);
252 }
253 }
254
255 return lexicalHead;
256 }
257
258 private PhraseStructureNode leftmostTerminalChild() {
259 for (PhraseStructureNode node : children) {
260 if (node instanceof TokenNode) {
261 return node;
262 }
263 }
264 return null;
265 }
266
267 private PhraseStructureNode leftmostNonTerminalChild() {
268 for (PhraseStructureNode node : children) {
269 if (node instanceof NonTerminalNode) {
270 return node;
271 }
272 }
273 return null;
274 }
275
276 private PhraseStructureNode rightmostTerminalChild() {
277 try {
278 if (children.last() instanceof TokenNode) {
279 return children.last();
280 }
281 } catch (NoSuchElementException e) { }
282
283 PhraseStructureNode candidate = null;
284 for (PhraseStructureNode node : children) {
285 if (node instanceof TokenNode) {
286 candidate = node;
287 }
288 }
289 return candidate;
290 }
291
292 private PhraseStructureNode rightmostNonTerminalChild() {
293 try {
294 if (children.last() instanceof NonTerminalNode) {
295 return children.last();
296 }
297 } catch (NoSuchElementException e) { }
298
299 PhraseStructureNode candidate = null;
300 for (PhraseStructureNode node : children) {
301 if (node instanceof NonTerminalNode) {
302 candidate = node;
303 }
304 }
305 return candidate;
306 }
307
308 public boolean hasAtMostOneHead() {
309 return true;
310 }
311
312 public boolean hasAncestorInside(int left, int right) throws MaltChainedException {
313 return false;
314 }
315
316 public boolean hasHead() {
317 return false;
318 }
319
320
321 public DependencyNode getHead() throws MaltChainedException {
322 return null;
323 }
324
325 public Edge getHeadEdge() throws MaltChainedException {
326 return null;
327 }
328
329 public void addHeadEdgeLabel(SymbolTable table, String symbol) throws MaltChainedException { }
330
331 public void addHeadEdgeLabel(SymbolTable table, int code) throws MaltChainedException { }
332
333 public void addHeadEdgeLabel(LabelSet labelSet) throws MaltChainedException { }
334
335 public int getHeadEdgeLabelCode(SymbolTable table) throws MaltChainedException {
336 return 0;
337 }
338
339 public LabelSet getHeadEdgeLabelSet() throws MaltChainedException {
340 return null;
341 }
342
343
344 public String getHeadEdgeLabelSymbol(SymbolTable table) throws MaltChainedException {
345 return null;
346 }
347
348 public Set<SymbolTable> getHeadEdgeLabelTypes() throws MaltChainedException {
349 return null;
350 }
351
352 public boolean hasHeadEdgeLabel(SymbolTable table) throws MaltChainedException {
353 return false;
354 }
355
356 public boolean isHeadEdgeLabeled() throws MaltChainedException {
357 return false;
358 }
359
360 public int nHeadEdgeLabels() throws MaltChainedException {
361 return 0;
362 }
363
364 public Set<Edge> getHeadEdges() throws MaltChainedException {
365 return null;
366 }
367
368 public Set<DependencyNode> getHeads() throws MaltChainedException {
369 return null;
370 }
371
372 public boolean hasDependent() {
373 return hasLeftDependent() || hasRightDependent();
374 }
375
376 /**
377 * Returns <code>true</code> if the node has one or more left dependents, otherwise <code>false</code>.
378 *
379 * @return <code>true</code> if the node has one or more left dependents, otherwise <code>false</code>.
380 */
381 public boolean hasLeftDependent() {
382 return !leftDependents.isEmpty();
383 }
384
385 /**
386 * Returns the left dependent at the position <code>index</code>, where <code>index==0</code> equals the left most dependent.
387 *
388 * @param index the index
389 * @return the left dependent at the position <code>index</code>, where <code>index==0</code> equals the left most dependent
390 */
391 public DependencyNode getLeftDependent(int index) {
392 if (0 <= index && index < leftDependents.size()) {
393 int i = 0;
394 DependencyNode candidate = null;
395
396 for (DependencyNode node : leftDependents) {
397 candidate = node;
398 if (i == index) {
399 return candidate;
400 }
401 i++;
402 }
403 }
404 return null;
405 }
406
407 /**
408 * Return the number of left dependents
409 *
410 * @return the number of left dependents
411 */
412 public int getLeftDependentCount() {
413 return leftDependents.size();
414 }
415
416 public SortedSet<DependencyNode> getLeftDependents() {
417 return leftDependents;
418 }
419
420 /**
421 * Returns the left sibling if it exists, otherwise <code>null</code>
422 *
423 * @return the left sibling if it exists, otherwise <code>null</code>
424 */
425 public DependencyNode getLeftSibling() throws MaltChainedException {
426 return null;
427 }
428
429 /**
430 * Returns the left sibling at the same side of head as the node it self. If not found <code>null</code is returned
431 *
432 * @return the left sibling at the same side of head as the node it self. If not found <code>null</code is returned
433 */
434 public DependencyNode getSameSideLeftSibling() throws MaltChainedException {
435 return null;
436 }
437
438 /**
439 * Returns the closest left dependent to the node it self, if not found <code>null</code> is returned.
440 *
441 * @return the closest left dependent to the node it self, if not found <code>null</code> is returned.
442 */
443 public DependencyNode getClosestLeftDependent() {
444 try {
445 return leftDependents.last();
446 } catch (NoSuchElementException e) {
447 return null;
448 }
449 }
450
451 public DependencyNode getLeftmostDependent() {
452 for (DependencyNode dep : leftDependents) {
453 return dep;
454 }
455 return null;
456 // try {
457 // return leftDependents.first();
458 // } catch (NoSuchElementException e) {
459 // return null;
460 // }
461 }
462
463 public DependencyNode getRightDependent(int index) {
464 int size = rightDependents.size();
465 if (index < size) {
466 return rightDependents.toArray(new DependencyNode[size])[size - 1 - index];
467 }
468 return null;
469 // if (0 <= index && index < rightDependents.size()) {
470 // int i = 0;
471 // DependencyNode candidate = null;
472 //
473 // for (DependencyNode node : rightDependents) {
474 // candidate = node;
475 // if (i == index) {
476 // return candidate;
477 // }
478 // i++;
479 // }
480 // }
481 // return null;
482 }
483
484 /**
485 * Return the number of right dependents
486 *
487 * @return the number of right dependents
488 */
489 public int getRightDependentCount() {
490 return rightDependents.size();
491 }
492
493 public SortedSet<DependencyNode> getRightDependents() {
494 return rightDependents;
495 }
496
497 /**
498 * Returns the right sibling if it exists, otherwise <code>null</code>
499 *
500 * @return the right sibling if it exists, otherwise <code>null</code>
501 */
502 public DependencyNode getRightSibling() throws MaltChainedException {
503 return null;
504 }
505
506 /**
507 * Returns the right sibling at the same side of head as the node it self. If not found <code>null</code is returned
508 *
509 * @return the right sibling at the same side of head as the node it self. If not found <code>null</code is returned
510 */
511 public DependencyNode getSameSideRightSibling() throws MaltChainedException {
512 return null;
513 }
514
515 /**
516 * Returns the closest right dependent to the node it self, if not found <code>null</code> is returned.
517 *
518 * @return the closest right dependent to the node it self, if not found <code>null</code> is returned.
519 */
520 public DependencyNode getClosestRightDependent() {
521 for (DependencyNode dep : rightDependents) {
522 return dep;
523 }
524 return null;
525 // try {
526 // return rightDependents.first();
527 // } catch (NoSuchElementException e) {
528 // return null;
529 // }
530 }
531
532 public DependencyNode getRightmostDependent() {
533 int n = rightDependents.size();
534 int i = 1;
535 for (DependencyNode node : rightDependents) {
536 if (i == n) {
537 return node;
538 }
539 i++;
540 }
541 return null;
542 // try {
543 // return rightDependents.last();
544 // } catch (NoSuchElementException e) {
545 // return null;
546 // }
547 }
548
549 /**
550 * Returns <code>true</code> if the node has one or more right dependents, otherwise <code>false</code>.
551 *
552 * @return <code>true</code> if the node has one or more right dependents, otherwise <code>false</code>.
553 */
554 public boolean hasRightDependent() {
555 return !rightDependents.isEmpty();
556 }
557
558 protected void getDependencyDominationSet(SortedSet<DependencyNode> dominationSet) {
559 if (leftDependents.size() > 0 || rightDependents.size() > 0) {
560 dominationSet.addAll(leftDependents);
561 dominationSet.addAll(rightDependents);
562
563 for (DependencyNode node : leftDependents) {
564 ((Token)node).getDependencyDominationSet(dominationSet);
565 }
566 for (DependencyNode node : rightDependents) {
567 ((Token)node).getDependencyDominationSet(dominationSet);
568 }
569 }
570 }
571
572 // private SortedSet<DependencyNode> getDependencyDominationSet() {
573 // SortedSet<DependencyNode> dominationSet = new TreeSet<DependencyNode>();
574 // getDependencyDominationSet(dominationSet);
575 // return dominationSet;
576 // }
577
578 public boolean isProjective() throws MaltChainedException {
579 return true;
580 }
581
582 public int getDependencyNodeDepth() throws MaltChainedException {
583 return 0;
584 }
585 @Override
586 public int getIndex() {
587 return 0;
588 }
589
590 public int getCompareToIndex() {
591 return 0;
592 }
593
594 @Override
595 public boolean isRoot() {
596 return true;
597 }
598
599 public ComparableNode getLeftmostProperDescendant() throws MaltChainedException {
600 NonTerminalNode node = this;
601 ComparableNode candidate = null;
602 while (node != null) {
603 candidate = node.getLeftChild();
604 if (candidate == null || candidate instanceof TokenNode) {
605 break;
606 }
607 node = (NonTerminalNode)candidate;
608 }
609
610 if (candidate == null && candidate instanceof NonTerminalNode) {
611 candidate = null;
612 DependencyNode dep = null;
613 for (int index : ((TokenStructure)getBelongsToGraph()).getTokenIndices()) {
614 dep = ((TokenStructure)getBelongsToGraph()).getTokenNode(index);
615 while (dep != null) {
616 if (dep == this ) {
617 return dep;
618 }
619 dep = dep.getHead();
620 }
621 }
622 }
623 return candidate;
624 }
625
626 public ComparableNode getRightmostProperDescendant() throws MaltChainedException {
627 NonTerminalNode node = this;
628 ComparableNode candidate = null;
629 while (node != null) {
630 candidate = node.getRightChild();
631 if (candidate == null || candidate instanceof TokenNode) {
632 break;
633 }
634 node = (NonTerminalNode)candidate;
635 }
636 if (candidate == null && candidate instanceof NonTerminalNode) {
637 candidate = null;
638 DependencyNode dep = null;
639 for (int i = ((TokenStructure)getBelongsToGraph()).getHighestTokenIndex(); i > 0; i--) {
640 dep = ((TokenStructure)getBelongsToGraph()).getTokenNode(i);
641 while (dep != null) {
642 if (dep == this ) {
643 return dep;
644 }
645 dep = dep.getHead();
646 }
647 }
648 }
649 return candidate;
650 }
651
652 public ComparableNode getLeftmostDescendant() throws MaltChainedException {
653 return getLeftmostProperDescendant();
654 }
655
656 public ComparableNode getRightmostDescendant() throws MaltChainedException {
657 return getRightmostProperDescendant();
658 }
659
660 // public void reArrangeChildrenAccordingToLeftAndRightProperDesendant() throws MaltChainedException {
661 // int i = 0;
662 // int leftMostCorner = -1;
663 // int leftMostCornerChildIndex = -1;
664 // while (i < children.size()) {
665 // if (leftMostCorner == -1) {
666 // leftMostCorner = getChild(i).getLeftmostProperDescendantIndex();
667 // leftMostCornerChildIndex = i;
668 // } else if (getChild(i) instanceof NonTerminal && getChild(i).getLeftmostProperDescendantIndex() < leftMostCorner) {
669 // NonTerminalNode child = (NonTerminal)getChild(i);
670 // PhraseStructureNode leftMostCornerChild = getChild(leftMostCornerChildIndex);
671 // if (leftMostCornerChild.getParent() != null) {
672 // LabelSet labelSet = leftMostCornerChild.getParentEdge().getLabelSet();
673 // ((PhraseStructure)getBelongsToGraph()).removePhraseStructureEdge(this, leftMostCornerChild);
674 // Edge e = ((PhraseStructure)getBelongsToGraph()).addPhraseStructureEdge(child, leftMostCornerChild);
675 // e.addLabel(labelSet);
676 // }
677 // child.reArrangeChildrenAccordingToLeftAndRightProperDesendant();
678 // i = -1;
679 // leftMostCorner = -1;
680 // leftMostCornerChildIndex = -1;
681 // } else {
682 // leftMostCorner = getChild(i).getLeftmostProperDescendantIndex();
683 // leftMostCornerChildIndex = i;
684 // }
685 // i++;
686 // }
687 //
688 // for (int j = 0, n=children.size(); j < n; j++) {
689 // if (getChild(j) instanceof NonTerminalNode) {
690 // ((NonTerminalNode)getChild(j)).reArrangeChildrenAccordingToLeftAndRightProperDesendant();
691 // }
692 // }
693 // }
694
695 @Override
696 public void setIndex(int index) throws MaltChainedException { }
697
698 public void clear() throws MaltChainedException {
699 super.clear();
700 component = this;
701 rank = 0;
702 leftDependents.clear();
703 rightDependents.clear();
704 children.clear();
705 }
706
707 public int compareTo(ComparableNode o) {
708 final int BEFORE = -1;
709 final int EQUAL = 0;
710 final int AFTER = 1;
711 if ( this == o ) return EQUAL;
712 try {
713 final int thisLCorner = this.getLeftmostProperDescendantIndex();
714 final int thatLCorner = (o instanceof TokenNode)?o.getCompareToIndex():o.getLeftmostProperDescendantIndex();
715 final int thisRCorner = this.getRightmostProperDescendantIndex();
716 final int thatRCorner = (o instanceof TokenNode)?o.getCompareToIndex():o.getRightmostProperDescendantIndex();
717
718 // if (thisLCorner == -1 || thatLCorner == -1) {
719 // if (thisRCorner < thatRCorner) return BEFORE;
720 // if (thisRCorner > thatRCorner) return AFTER;
721 // }
722 // if (thisRCorner == -1 || thatRCorner == -1) {
723 // if (thisLCorner < thatLCorner) return BEFORE;
724 // if (thisLCorner > thatLCorner) return AFTER;
725 // }
726 if (thisLCorner != -1 && thatLCorner != -1 && thisRCorner != -1 && thatRCorner != -1) {
727 if (thisLCorner < thatLCorner && thisRCorner < thatRCorner) return BEFORE;
728 if (thisLCorner > thatLCorner && thisRCorner > thatRCorner) return AFTER;
729 if (thisLCorner > thatLCorner && thisRCorner < thatRCorner) return BEFORE;
730 if (thisLCorner < thatLCorner && thisRCorner > thatRCorner) return AFTER;
731 } else {
732 if (thisLCorner != -1 && thatLCorner != -1) {
733 if (thisLCorner < thatLCorner) return BEFORE;
734 if (thisLCorner > thatLCorner) return AFTER;
735 }
736 if (thisRCorner != -1 && thatRCorner != -1) {
737 if (thisRCorner < thatRCorner) return BEFORE;
738 if (thisRCorner > thatRCorner) return AFTER;
739 }
740 }
741
742 // final int thisLCorner = this.getLeftmostDescendantIndex();
743 // final int thatLCorner = (o instanceof TerminalNode)?o.getCompareToIndex():o.getLeftmostDescendantIndex();
744 // final int thisRCorner = this.getRightmostDescendantIndex();
745 // final int thatRCorner = (o instanceof TerminalNode)?o.getCompareToIndex():o.getRightmostDescendantIndex();
746 //
747 // if (thisLCorner == -1 || thatLCorner == -1) {
748 // if (thisRCorner < thatRCorner) return BEFORE;
749 // if (thisRCorner > thatRCorner) return AFTER;
750 // }
751 // if (thisRCorner == -1 || thatRCorner == -1) {
752 // if (thisLCorner < thatLCorner) return BEFORE;
753 // if (thisLCorner > thatLCorner) return AFTER;
754 // }
755 // if (thisLCorner < thatLCorner && thisRCorner < thatRCorner) return BEFORE;
756 // if (thisLCorner > thatLCorner && thisRCorner > thatRCorner) return AFTER;
757 // if (thisLCorner > thatLCorner && thisRCorner < thatRCorner) return BEFORE;
758 // if (thisLCorner < thatLCorner && thisRCorner > thatRCorner) return AFTER;
759
760
761 // int thisCorner = this.getLeftmostDescendantIndex();
762 // int thatCorner = (o instanceof TerminalNode)?o.getCompareToIndex():o.getLeftmostDescendantIndex();
763 // if (thisCorner != -1 && thatCorner != -1) {
764 // if (thisCorner < thatCorner) return BEFORE;
765 // if (thisCorner > thatCorner) return AFTER;
766 // }
767 // thisCorner = this.getRightmostDescendantIndex();
768 // thatCorner = (o instanceof TerminalNode)?o.getCompareToIndex():o.getRightmostDescendantIndex();
769 // if (thisCorner != -1 && thatCorner != -1) {
770 // if (thisCorner < thatCorner) return BEFORE;
771 // if (thisCorner > thatCorner) return AFTER;
772 // }
773 } catch (MaltChainedException e) {
774 if (SystemLogger.logger().isDebugEnabled()) {
775 SystemLogger.logger().debug("",e);
776 } else {
777 SystemLogger.logger().error(e.getMessageChain());
778 }
779 System.exit(1);
780 }
781 if (0 < o.getCompareToIndex()) return BEFORE;
782 if (0 > o.getCompareToIndex()) return AFTER;
783 return super.compareTo(o);
784 //
785 // if (o instanceof TerminalNode) {
786 // if (0 == o.getIndex()) {
787 //
788 // } else if (0 < o.getIndex()) {
789 // return -1;
790 // } else {
791 // return 1;
792 // }
793 // } else if (o instanceof Root) {
794 // return super.compareTo(o);
795 // } else if (o instanceof NonTerminalNode) {
796 // int lcorner = ((NonTerminalNode)o).getLeftCornerIndex();
797 // if (0 == lcorner) {
798 // int rcorner = ((NonTerminalNode)o).getRightCornerIndex();
799 // if (0 == rcorner) {
800 // if (0 == o.getIndex()) {
801 // return super.compareTo(o);
802 // } else if (0 < o.getIndex()) {
803 // return 1;
804 // } else {
805 // return -1;
806 // }
807 // } else if (0 < rcorner) {
808 // return -1;
809 // } else {
810 // return 1;
811 // }
812 // } else if (0 < lcorner) {
813 // return -1;
814 // } else {
815 // return 1;
816 // }
817 // }
818 // return super.compareTo(o);
819 }
820
821 public boolean equals(Object obj) {
822 return super.equals(obj);
823 }
824
825 public int hashCode() {
826 return 31 * 7 + super.hashCode();
827 }
828
829 public String toString() {
830 StringBuilder sb = new StringBuilder();
831 sb.append(super.toString());
832 return sb.toString();
833 }
834 }