bundles/org.simantics.document.linking.ui/src/org/simantics/document/linking/report/evaluator/EvaluatorNode.java

   1 package org.simantics.document.linking.report.evaluator;
   2
   3 import java.util.ArrayList;
   4 import java.util.List;
   5
   6 import org.simantics.objmap.graph.annotations.OrderedElementsAdd;
   7 import org.simantics.objmap.graph.annotations.OrderedElementsGet;
   8 import org.simantics.objmap.graph.annotations.OrderedElementsRem;
   9
  10 public abstract class EvaluatorNode implements EvaluatorItem{
  11
  12         EvaluatorNode parent;
  13
  14         List<EvaluatorItem> children = new ArrayList<EvaluatorItem>();
  15
  16
  17         @Override
  18         public EvaluatorNode getParent() {
  19                 return parent;
  20         }
  21
  22         @Override
  23         public void setParent(EvaluatorNode parent) {
  24                 this.parent = parent;
  25         }
  26
  27         @OrderedElementsGet
  28         public List<EvaluatorItem> getChildren() {
  29                 return children;
  30         }
  31
  32         public boolean acceptChild(EvaluatorItem item) {
  33                 return true;
  34         }
  35
  36         public boolean acceptChild(int index, EvaluatorItem item) {
  37                 return true;
  38         }
  39
  40         public void addChild(EvaluatorItem item) {
  41                 children.add(item);
  42                 item.setParent(this);
  43         }
  44
  45         @OrderedElementsAdd
  46         public void addChild(int index, EvaluatorItem item) {
  47                 children.add(index, item);
  48                 item.setParent(this);
  49         }
  50
  51         public int indexOf(EvaluatorItem item) {
  52                 return children.indexOf(item);
  53         }
  54
  55         @OrderedElementsRem
  56         public void removeChild(EvaluatorItem item) {
  57                 children.remove(item);
  58                 item.setParent(null);
  59         }
  60
  61
  62         public List<Class<? extends EvaluatorItem>> getPossibleChildren(boolean add) {
  63                 List<Class<? extends EvaluatorItem>> classes = new ArrayList<Class<? extends EvaluatorItem>>();
  64                 classes.add(And.class);
  65                 classes.add(Or.class);
  66                 classes.add(If.class);
  67                 classes.add(Constant.class);
  68                 classes.add(Variable.class);
  69                 classes.add(Date.class);
  70                 classes.add(Path.class);
  71                 EvaluatorRoot root = getRoot();
  72                 if (root != null && root.isSupportStyles()) {
  73                         classes.add(TextSizeHint.class);
  74                         classes.add(AlignmentHint.class);
  75                 }
  76
  77                 return classes;
  78         }
  79
  80         @SuppressWarnings("unchecked")
  81         public <T extends EvaluatorItem> T createChild(Class<T> cls) {
  82                 EvaluatorItem child;
  83                 try {
  84                         child = cls.newInstance();
  85                         if (child instanceof EvaluatorNode)
  86                                 ((EvaluatorNode)child).parent = this;
  87                         else if (child instanceof EvaluatorLeaf) {
  88                                 ((EvaluatorLeaf)child).parent = this;
  89                         }
  90                         addChild(child);
  91                         return (T)child;
  92                 } catch (Exception e) {
  93
  94                 }
  95                 return null;
  96         }
  97
  98         @SuppressWarnings("unchecked")
  99         public <T extends EvaluatorItem> T createChild(int index, Class<T> cls) {
 100                 EvaluatorItem child;
 101                 try {
 102                         child = cls.newInstance();
 103                         if (child instanceof EvaluatorNode)
 104                                 ((EvaluatorNode)child).parent = this;
 105                         else if (child instanceof EvaluatorLeaf) {
 106                                 ((EvaluatorLeaf)child).parent = this;
 107                         }
 108                         addChild(child);
 109                         return (T)child;
 110                 } catch (Exception e) {
 111
 112                 }
 113                 return null;
 114
 115         }
 116
 117         @Override
 118         public EvaluatorRoot getRoot() {
 119                 if (parent == null)
 120                         return null;
 121                 return parent.getRoot();
 122         }
 123
 124         protected void copyChildren(EvaluatorNode copy) {
 125                 for (EvaluatorItem i : children) {
 126                         copy.addChild(i.copy());
 127                 }
 128         }
 129
 130 }