Add more databoard reading utilities to ByteFileReader

[simantics/platform.git] / bundles / org.simantics.history / src / org / simantics / history / impl / CollectorImpl.java

diff --git a/bundles/org.simantics.history/src/org/simantics/history/impl/CollectorImpl.java b/bundles/org.simantics.history/src/org/simantics/history/impl/CollectorImpl.java
index d6dd6d9b33f19baf7bca38f773d99f9530508f6e..c202f733ca6af88c284351de3cfadea3eee9899d 100644 (file)
--- a/bundles/org.simantics.history/src/org/simantics/history/impl/CollectorImpl.java
+++ b/bundles/org.simantics.history/src/org/simantics/history/impl/CollectorImpl.java
@@ -87,6 +87,15 @@ public class CollectorImpl implements Collector {
        
        /** True when all items are open */
        boolean itemsOpen = true;
+
+       /** True when history collection will write data to disk */
+       boolean enabled = true;
+
+       /**
+        * Transient info only set in {@link #beginStep(NumberBinding, Object)} based on
+        * {@link #enabled}
+        */
+       private transient boolean stepEnabled = true;
        
        public FlushPolicy flushPolicy = FlushPolicy.FlushOnEveryStep;
        
@@ -122,7 +131,16 @@ public class CollectorImpl implements Collector {
                this.history = history;
                this.state = (CollectorState) previousState.clone();
        }
-       
+
+       public void setEnabled(boolean enabled) {
+               this.enabled = enabled;
+       }
+
+       @Override
+       public boolean isEnabled() {
+               return enabled;
+       }
+
        @Override
        public synchronized void addItem(Bean item) throws HistoryException {
                try {
@@ -494,13 +512,20 @@ public class CollectorImpl implements Collector {
        
        @Override
        public void beginStep(NumberBinding binding, Object time) throws HistoryException {
-               openAllItems();
+               stepEnabled = enabled;
                updateDt(binding, time);
                state.time.setValue(binding, time);
+               if (enabled) {
+                       openAllItems();
+               }
        }
 
        @Override
        public void setValue(String id, Binding binding, Object value) throws HistoryException {
+               // Short-circuit calls when collection not enabled
+               if (!stepEnabled)
+                       return;
+
                VariableState vs = state.values.get( id );
                if (vs == null) {
                        vs = new VariableState();
@@ -554,6 +579,8 @@ public class CollectorImpl implements Collector {
 
        @Override
        public void endStep() throws HistoryException {
+               if (!stepEnabled)
+                       return;
                // Write values to streams
                for (ActiveStream i : items)
                {
@@ -811,58 +838,69 @@ public class CollectorImpl implements Collector {
                
                boolean condition = makeNewBand || (!i.hasEndTime && i.itemState.count==2); 
 
-               if(i.stream.size() > 0 ) { //!i.itemState.ooDeadband) {
+               if (i.stream.size() > 0) {
 
                        /// Extend existing band
                        // Extend endTime value
-                       if (!i.hasEndTime) {
-                               i.current.setTime( time.getBinding(), time.getValue() );
-                       } else {
-                               i.current.setEndTime( time.getBinding(), time.getValue() );
+
+                       // This ensures that a value band's end time isn't the same
+                       // as the next band's start time which makes it possible to
+                       // know what are the timestamps between which the item value
+                       // changed from a to b. This allows us to more correctly render
+                       // steps and sloped lines accoring to the actual data.
+                       if (!i.itemState.ooDeadband || isMinMaxFormat) {
+                               if (!i.hasEndTime) {
+                                       i.current.setTime( time.getBinding(), time.getValue() );
+                               } else {
+                                       i.current.setEndTime( time.getBinding(), time.getValue() );
+                               }
                        }
-                       if  (i.itemState.ooDeadband) {
+
+                       if (i.itemState.ooDeadband || isMinMaxFormat) {
                                if (isValidValue) {
                                        // Set last value
                                        if (i.current.hasLastValue()) {
                                                i.current.setLastValue( value.getBinding(), value.getValue() );
                                        }
 
-                                       // Add sum
-                                       if (i.current.hasAvg() && i.isNumeric && !isNanValue && !restep) {
-                                               double duration = (currentTime - i.itemState.firstTime);
-                                               if(duration < 1e-9) {
-                                                       i.current.setAvg( Bindings.DOUBLE, 0.0 );
-                                               } else {
-                                                       i.current.setAvg( Bindings.DOUBLE, i.itemState.sum / duration);
+                                       if (i.isNumeric && !isNanValue) {
+                                               // Add sum
+                                               if (i.current.hasAvg() && !restep) {
+                                                       double duration = (currentTime - i.itemState.firstTime);
+                                                       if(duration < 1e-9) {
+                                                               i.current.setAvg( Bindings.DOUBLE, 0.0 );
+                                                       } else {
+                                                               i.current.setAvg( Bindings.DOUBLE, i.itemState.sum / duration);
+                                                       }
                                                }
-                                       }
 
-                                       // Update min-max
-                                       if (i.current.hasMin() && i.isNumeric && !isNanValue) {
-                                               Binding minBinding = i.current.getMinBinding();
-                                               Object prevMinValue = i.current.getMin();
-                                               Object currentValueWithMinBinding = value.getValue( minBinding );
-                                               int diff = minBinding.compare( prevMinValue, currentValueWithMinBinding );
-                                               if (diff>0) i.current.setMin( minBinding, currentValueWithMinBinding );
-                                       }
-                                       if (i.current.hasMax() && i.isNumeric && !isNanValue) {
-                                               Binding maxBinding = i.current.getMaxBinding();
-                                               Object prevMaxValue = i.current.getMax();
-                                               Object currentValueWithMaxBinding = value.getValue( maxBinding );
-                                               int diff = maxBinding.compare( prevMaxValue, currentValueWithMaxBinding );
-                                               if (diff<0) i.current.setMax( maxBinding, currentValueWithMaxBinding );
-                                       }
+                                               // Update min-max
+                                               if (i.current.hasMin()) {
+                                                       Binding minBinding = i.current.getMinBinding();
+                                                       Object prevMinValue = i.current.getMin();
+                                                       Object currentValueWithMinBinding = value.getValue( minBinding );
+                                                       int diff = minBinding.compare( prevMinValue, currentValueWithMinBinding );
+                                                       if (diff>0) i.current.setMin( minBinding, currentValueWithMinBinding );
+                                               }
+                                               if (i.current.hasMax()) {
+                                                       Binding maxBinding = i.current.getMaxBinding();
+                                                       Object prevMaxValue = i.current.getMax();
+                                                       Object currentValueWithMaxBinding = value.getValue( maxBinding );
+                                                       int diff = maxBinding.compare( prevMaxValue, currentValueWithMaxBinding );
+                                                       if (diff<0) i.current.setMax( maxBinding, currentValueWithMaxBinding );
+                                               }
 
-                                       // Update median
-                                       if (i.current.hasMedian() && i.isNumeric && !isNanValue) {
-                                               Double median = i.itemState.median.getMedian();
-                                               i.current.setMedian( Bindings.DOUBLE, median);
+                                               // Update median
+                                               if (i.current.hasMedian()) {
+                                                       Double median = i.itemState.median.getMedian();
+                                                       i.current.setMedian( Bindings.DOUBLE, median);
+                                               }
                                        }
                                } else {
                                        i.current.setValueNull();
                                }
 
-                               // Add count
+                               // Update count
                                if (i.current.hasCount()) {
                                        i.current.setCount( i.itemState.count );
                                }