bundles/org.simantics.spreadsheet.graph/src/org/simantics/spreadsheet/graph/SpreadsheetLines.java

   1 package org.simantics.spreadsheet.graph;
   2
   3 import java.util.Collection;
   4 import java.util.Collections;
   5 import java.util.Map;
   6 import java.util.Optional;
   7
   8 import org.simantics.spreadsheet.resource.SpreadsheetResource;
   9
  10 import it.unimi.dsi.fastutil.ints.Int2ObjectAVLTreeMap;
  11
  12 public class SpreadsheetLines implements SpreadsheetElement<SpreadsheetLine, SpreadsheetEngine>, SheetNode {
  13
  14         private static final long serialVersionUID = -3615335969248723486L;
  15
  16         private final int id;
  17         private SpreadsheetEngine parent;
  18         private String name;
  19         public Int2ObjectAVLTreeMap<SpreadsheetLines> nodes = new Int2ObjectAVLTreeMap<SpreadsheetLines>();
  20         public Int2ObjectAVLTreeMap<SpreadsheetLine> lines = new Int2ObjectAVLTreeMap<SpreadsheetLine>();
  21         public int[] keys;
  22
  23         public SpreadsheetLines(SpreadsheetEngine parent, String name) {
  24                 this.parent = parent;
  25                 this.name = name;
  26                 id = getEngine().getBook().getNewId(this);
  27         }
  28
  29         public SpreadsheetEngine getEngine() {
  30                 return parent;
  31         }
  32
  33         public int getId() {
  34                 return id;
  35         }
  36
  37         @Override
  38         public String getName() {
  39                 return name;
  40         }
  41
  42         @Override
  43         public Map getChildren() {
  44                 Int2ObjectAVLTreeMap result = new Int2ObjectAVLTreeMap();
  45                 result.putAll(nodes);
  46                 result.putAll(lines);
  47                 return result;
  48         }
  49
  50         @Override
  51         public Map getProperties() {
  52                 return Collections.singletonMap("typeURI", new SpreadsheetTypeNode(SpreadsheetResource.URIs.Lines));
  53         }
  54
  55         Object resolve(String[] parts, int index) {
  56
  57                 String part = parts[index];
  58                 if(part.charAt(0) == 'R') {
  59                         int indx = Integer.parseInt(part.substring(3));
  60                         SpreadsheetLine line = lines.get(-indx);
  61                         if(line != null) {
  62                                 if(index == parts.length-1) return line;
  63                                 else return line.resolve(parts, index+1);
  64                         }
  65                 } else {
  66                         int indx = Integer.parseInt(part);
  67                         SpreadsheetLines node = nodes.get(indx);
  68                         if(node != null) {
  69                                 if(index == parts.length-1) return node;
  70                                 else return node.resolve(parts, index+1);
  71                         }
  72                 }
  73
  74                 return null;
  75
  76         }
  77
  78         public Object ensureSubprocess(String[] path, int index) {
  79
  80                 String name = path[index];
  81
  82                 int i = Integer.parseInt(name);
  83                 SpreadsheetLines line = nodes.get(i);
  84                 if(line == null) {
  85                         line = new SpreadsheetLines(parent, "" + i);
  86                         nodes.put(i, line);
  87                 }
  88
  89                 if(index == path.length - 1) {
  90                         return line;
  91                 } else {
  92                         return line.ensureSubprocess(path, index+1);
  93                 }
  94
  95         }
  96
  97         public void setKeys(int[] keys) {
  98                 this.keys = keys;
  99         }
 100
 101         @Override
 102         public void accept(SpreadsheetVisitor v) {
 103                 v.visit(this);
 104         }
 105
 106         public String getPath() {
 107                         return "/" + parent.getName() + "/" + parent.lines.getName() + "/" + getName();
 108         }
 109
 110         private int getKey(int index) {
 111                 return keys[2*index+1];
 112         }
 113
 114         private int getChild(int index) {
 115                 return keys[2*index];
 116         }
 117
 118         /*
 119          *  [(child,key),...,key)
 120          *
 121          */
 122         public SpreadsheetLine getLine(int k) {
 123
 124                 int i=1;
 125                 int n = (keys.length - 1) / 2;
 126
 127                 while(i <= n && k > getKey(i-1)) i++;
 128
 129                 if(i <= n && k == getKey(i-1)) {
 130                         return lines.get(-k);
 131                 }
 132
 133                 int nodeName = getChild(i-1);
 134                 SpreadsheetLines node = nodes.get(nodeName);
 135                 if(node == null) return null;
 136                 return node.getLine(k);
 137
 138         }
 139
 140         public int getMaxRow() {
 141                 // if keys == null then this is the root of BTree which has only one child
 142                 if (keys == null) {
 143                         int maxRow = 0;
 144                         for (SpreadsheetLines node : nodes.values()) {
 145                                 int row = node.getMaxRow();
 146                                 if (row > maxRow)
 147                                         maxRow = row;
 148                         }
 149                         return maxRow;
 150                 }
 151                 int largestChild = keys[keys.length-1];
 152                 if(largestChild > 0) {
 153                         SpreadsheetLines child = nodes.get(largestChild);
 154                         return child.getMaxRow();
 155                 } else {
 156                         return keys[keys.length-2];
 157                 }
 158         }
 159
 160     @Override
 161     public Optional<SpreadsheetEngine> getParent() {
 162         return Optional.of(parent);
 163     }
 164
 165     @Override
 166     public Collection<SpreadsheetLine> getSpreadsheetChildren() {
 167         return lines.values();
 168     }
 169
 170     @Override
 171     public void remove(SpreadsheetLine child) {
 172         lines.remove(-child.row);
 173     }
 174
 175     @Override
 176     public int hashCode() {
 177         final int prime = 31;
 178         int result = 1;
 179         result = prime * result + ((name == null) ? 0 : name.hashCode());
 180         result = prime * result + ((parent == null) ? 0 : parent.hashCode());
 181         return result;
 182     }
 183
 184     @Override
 185     public boolean equals(Object obj) {
 186         if (this == obj)
 187             return true;
 188         if (obj == null)
 189             return false;
 190         if (getClass() != obj.getClass())
 191             return false;
 192         SpreadsheetLines other = (SpreadsheetLines) obj;
 193         if (name == null) {
 194             if (other.name != null)
 195                 return false;
 196         } else if (!name.equals(other.name))
 197             return false;
 198         if (parent == null) {
 199             if (other.parent != null)
 200                 return false;
 201         } else if (!parent.equals(other.parent))
 202             return false;
 203         return true;
 204     }
 205
 206 }