bundles/org.simantics.spreadsheet/src/org/simantics/spreadsheet/solver/SpreadsheetEngine.java

   1 package org.simantics.spreadsheet.solver;
   2
   3 import java.util.ArrayList;
   4 import java.util.Collections;
   5 import java.util.HashMap;
   6 import java.util.List;
   7 import java.util.Map;
   8 import java.util.Optional;
   9 import java.util.function.Consumer;
  10
  11 import org.simantics.spreadsheet.Range;
  12 import org.simantics.spreadsheet.SpreadsheetVisitor;
  13 import org.simantics.spreadsheet.solver.formula.parser.ast.AstRange;
  14
  15 @SuppressWarnings("rawtypes")
  16 public class SpreadsheetEngine implements SpreadsheetElement, SheetNode {
  17
  18     private static final long serialVersionUID = -5246063647558595642L;
  19
  20     private static final String LINES = "Lines";
  21
  22     private final SpreadsheetBook book;
  23     private final String name;
  24     private final int id;
  25
  26     public SpreadsheetLines lines;
  27
  28     transient public Map<String,Object> rangeCache;
  29
  30     public Map<String,Object> getRangeCache() {
  31         if(rangeCache == null) rangeCache = new HashMap<String,Object>();
  32         return rangeCache;
  33     }
  34
  35     public Object getCachedRange(AstRange range) {
  36         if(range.sheetName != null) return null;
  37         return getRangeCache().get(range.first + ":" + range.second);
  38     }
  39
  40     public void cacheRange(AstRange range, Object value) {
  41         if(range.sheetName != null) return;
  42         getRangeCache().put(range.first + ":" + range.second, value);
  43     }
  44
  45     public SpreadsheetEngine(SpreadsheetBook book, String name) {
  46         this.book = book;
  47         this.name = name;
  48         this.id = book.getNewId(this);
  49         this.lines = new SpreadsheetLines(this, LINES);
  50     }
  51
  52     public SpreadsheetBook getBook() {
  53         return book;
  54     }
  55
  56     public int getId() {
  57         return id;
  58     }
  59
  60     Object resolve(String[] parts, int index) {
  61
  62         String part = parts[index];
  63         if(!part.equals(LINES)) return null;
  64
  65         if(index == parts.length-1) return lines;
  66
  67         return lines.resolve(parts, index+1);
  68
  69     }
  70
  71     @Override
  72     public String getName() {
  73         return name;
  74     }
  75
  76     @Override
  77     public Map<String, SheetNode> getChildren() {
  78         return Collections.singletonMap(LINES, lines);
  79     }
  80
  81     @Override
  82     public Map<String, SheetNode> getProperties() {
  83         return Collections.emptyMap();
  84     }
  85
  86     public Object ensureSubprocess(String[] path, int index) {
  87
  88         String name = path[index];
  89         if(!LINES.equals(name)) throw new IllegalStateException();
  90         if(index == path.length - 1) return lines;
  91         return lines.ensureSubprocess(path, index+1);
  92
  93     }
  94
  95     public SpreadsheetLine getLine(int row) {
  96         assert(lines.nodes.size() == 1);
  97         SpreadsheetLines root = lines.nodes.values().iterator().next();
  98         return root.getLine(row);
  99     }
 100
 101     public void forLines(Consumer<SpreadsheetLine> consumer, int min, int max) {
 102         assert(lines.nodes.size() == 1);
 103         SpreadsheetLines root = lines.nodes.values().iterator().next();
 104         root.forLines(consumer, min, max);
 105     }
 106
 107     public List<SpreadsheetLine> getLines(int min, int max) {
 108         ArrayList<SpreadsheetLine> result = new ArrayList<>();
 109         forLines(line -> result.add(line), min, max);
 110         return result;
 111     }
 112
 113     @Override
 114     public void accept(SpreadsheetVisitor v) {
 115         v.visit(this);
 116     }
 117
 118     public Range actualRange(Range r) {
 119         if(r.isFullRows()) {
 120             SpreadsheetLines root = lines.nodes.values().iterator().next();
 121             Range result = new Range(r);
 122             result.startRow = 0;
 123             result.endRow = root.getMaxRow();
 124             return result;
 125         } else {
 126             return r;
 127         }
 128     }
 129
 130     @Override
 131     public Optional<SpreadsheetElement> getParent() {
 132         return Optional.of(book);
 133     }
 134
 135     @Override
 136     public List<SpreadsheetElement> getSpreadsheetChildren() {
 137         return Collections.singletonList(lines);
 138     }
 139
 140     @Override
 141     public void remove(SpreadsheetElement child) {
 142
 143     }
 144
 145     @Override
 146     public int hashCode() {
 147         final int prime = 31;
 148         int result = 1;
 149         result = prime * result + ((book == null) ? 0 : book.hashCode());
 150         result = prime * result + ((name == null) ? 0 : name.hashCode());
 151         return result;
 152     }
 153
 154     @Override
 155     public boolean equals(Object obj) {
 156         if (this == obj)
 157             return true;
 158         if (obj == null)
 159             return false;
 160         if (getClass() != obj.getClass())
 161             return false;
 162         SpreadsheetEngine other = (SpreadsheetEngine) obj;
 163         if (book == null) {
 164             if (other.book != null)
 165                 return false;
 166         } else if (!book.equals(other.book))
 167             return false;
 168         if (name == null) {
 169             if (other.name != null)
 170                 return false;
 171         } else if (!name.equals(other.name))
 172             return false;
 173         return true;
 174     }
 175
 176
 177 }