Coverage Report - com.sun.javafx.runtime.location.DoubleVariable
 
Classes in this File Line Coverage Branch Coverage Complexity
DoubleVariable
82%
53/65
83%
30/36
0
DoubleVariable$1
100%
2/2
N/A
0
DoubleVariable$2
100%
3/3
N/A
0
DoubleVariable$3
33%
1/3
N/A
0
 
 1  
 package com.sun.javafx.runtime.location;
 2  
 
 3  
 import java.util.ArrayList;
 4  
 import java.util.List;
 5  
 
 6  
 import com.sun.javafx.runtime.AssignToBoundException;
 7  
 import com.sun.javafx.runtime.ErrorHandler;
 8  
 
 9  
 /**
 10  
  * DoubleVariable
 11  
  *
 12  
  * @author Brian Goetz
 13  
  */
 14  112
 public class DoubleVariable
 15  
         extends AbstractVariable<Double, DoubleLocation, DoubleBindingExpression>
 16  
         implements DoubleLocation {
 17  
 
 18  
     public static final double DEFAULT = 0.0;
 19  
 
 20  2740
     protected double $value = DEFAULT;
 21  
     private List<DoubleChangeListener> replaceListeners;
 22  
 
 23  
 
 24  
     public static DoubleVariable make() {
 25  2661
         return new DoubleVariable();
 26  
     }
 27  
 
 28  
     public static DoubleVariable make(double value) {
 29  48
         return new DoubleVariable(value);
 30  
     }
 31  
 
 32  
     public static DoubleVariable make(boolean lazy, DoubleBindingExpression binding, Location... dependencies) {
 33  4
         return new DoubleVariable(lazy, binding, dependencies);
 34  
     }
 35  
 
 36  
     public static DoubleVariable make(DoubleBindingExpression binding, Location... dependencies) {
 37  21
         return new DoubleVariable(false, binding, dependencies);
 38  
     }
 39  
 
 40  
     /** Create a bijectively bound variable */
 41  
     public static DoubleVariable makeBijective(ObjectVariable<Double> other) {
 42  0
         DoubleVariable me = DoubleVariable.make();
 43  0
         me.bijectiveBind(other);
 44  0
         return me;
 45  
     }
 46  
 
 47  5480
     protected DoubleVariable() { }
 48  
 
 49  
     protected DoubleVariable(double value) {
 50  48
         this();
 51  48
         $value = value;
 52  48
         setValid();
 53  48
     }
 54  
 
 55  
     protected DoubleVariable(boolean lazy, DoubleBindingExpression binding, Location... dependencies) {
 56  25
         this();
 57  25
         bind(lazy, binding);
 58  25
         addDependencies(dependencies);
 59  25
     }
 60  
 
 61  
 
 62  
     public double getAsDouble() {
 63  4207
         if (isBound() && !isValid())
 64  338
             update();
 65  4207
         return $value;
 66  
     }
 67  
 
 68  
     public Double get() {
 69  44
         return getAsDouble();
 70  
     }
 71  
 
 72  
     public boolean isNull() {
 73  0
         return false;
 74  
     }
 75  
 
 76  
     protected double replaceValue(double newValue) {
 77  3509
         double oldValue = $value;
 78  3509
         if (oldValue != newValue || !isInitialized() || !isEverValid()) {
 79  3334
             boolean notifyDependencies = isValid() || !isInitialized() || !isEverValid();
 80  3334
             $value = newValue;
 81  3334
             setValid();
 82  3334
             notifyListeners(oldValue, newValue, notifyDependencies);
 83  3334
         }
 84  
         else
 85  175
             setValid();
 86  3509
         return newValue;
 87  
     }
 88  
 
 89  
     protected DoubleBindingExpression makeBindingExpression(final DoubleLocation otherLocation) {
 90  41
         return new DoubleBindingExpression() {
 91  
             public double computeValue() {
 92  260
                 return otherLocation.getAsDouble();
 93  
             }
 94  
         };
 95  
     }
 96  
 
 97  
     public double setAsDouble(double value) {
 98  2898
         if (isBound() && $value != value)
 99  2
             throw new AssignToBoundException("Cannot assign to bound variable");
 100  2896
         return replaceValue(value);
 101  
     }
 102  
 
 103  
     public double setAsDoubleFromLiteral(final double value) {
 104  2052
         deferredLiteral = new DeferredInitializer() {
 105  
             public void apply() {
 106  2052
                 setAsDouble(value);
 107  2052
             }
 108  
         };
 109  2052
         return value;
 110  
     }
 111  
 
 112  
     public void setDefault() {
 113  0
         setAsDouble(DEFAULT);
 114  0
     }
 115  
 
 116  
     public Double set(Double value) {
 117  27
         if (value == null) {
 118  0
             ErrorHandler.nullToPrimitiveCoercion("Double");
 119  0
             setDefault();
 120  
         }
 121  
         else
 122  27
             setAsDouble(value);
 123  26
         return value;
 124  
     }
 125  
 
 126  
     @Override
 127  
     public void update() {
 128  
         try {
 129  982
             if (isBound() && !isValid())
 130  613
                 replaceValue(binding.computeValue());
 131  
         }
 132  0
         catch (RuntimeException e) {
 133  0
             ErrorHandler.bindException(e);
 134  0
             if (isInitialized())
 135  0
                 replaceValue(DEFAULT);
 136  982
         }
 137  982
     }
 138  
 
 139  
     public void addChangeListener(DoubleChangeListener listener) {
 140  109
         if (replaceListeners == null)
 141  109
             replaceListeners = new ArrayList<DoubleChangeListener>();
 142  109
         replaceListeners.add(listener);
 143  109
     }
 144  
 
 145  
     public void addChangeListener(final ObjectChangeListener<Double> listener) {
 146  3
         addChangeListener(new DoubleChangeListener() {
 147  
             public void onChange(double oldValue, double newValue) {
 148  0
                 listener.onChange(oldValue, newValue);
 149  0
             }
 150  
         });
 151  3
     }
 152  
 
 153  
     private void notifyListeners(double oldValue, double newValue, boolean notifyDependencies) {
 154  3334
         if (notifyDependencies)
 155  2919
             invalidateDependencies();
 156  3334
         if (replaceListeners != null) {
 157  149
             for (DoubleChangeListener listener : replaceListeners)
 158  149
                 listener.onChange(oldValue, newValue);
 159  
         }
 160  3334
     }
 161  
 
 162  
 }