1 /* 2 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. Oracle designates this 8 * particular file as subject to the "Classpath" exception as provided 9 * by Oracle in the LICENSE file that accompanied this code. 10 * 11 * This code is distributed in the hope that it will be useful, but WITHOUT 12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 14 * version 2 for more details (a copy is included in the LICENSE file that 15 * accompanied this code). 16 * 17 * You should have received a copy of the GNU General Public License version 18 * 2 along with this work; if not, write to the Free Software Foundation, 19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 20 * 21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 22 * or visit www.oracle.com if you need additional information or have any 23 * questions. 24 */ 25 26 package javafx.beans.binding; 27 28 import javafx.beans.value.ObservableLongValue; 29 import javafx.collections.FXCollections; 30 import javafx.collections.ObservableList; 31 import javafx.beans.value.ObservableValue; 32 33 /** 34 * A {@code LongExpression} is a {@link javafx.beans.value.ObservableLongValue} 35 * plus additional convenience methods to generate bindings in a fluent style. 36 * <p> 37 * A concrete sub-class of {@code LongExpression} has to implement the method 38 * {@link javafx.beans.value.ObservableLongValue#get()}, which provides the 39 * actual value of this expression. 40 * @since JavaFX 2.0 41 */ 42 public abstract class LongExpression extends NumberExpressionBase implements 43 ObservableLongValue { 44 45 @Override 46 public int intValue() { 47 return (int) get(); 48 } 49 50 @Override 51 public long longValue() { 52 return get(); 53 } 54 55 @Override 56 public float floatValue() { 57 return (float) get(); 58 } 59 60 @Override 61 public double doubleValue() { 62 return (double) get(); 63 } 64 65 @Override 66 public Long getValue() { 67 return get(); 68 } 69 70 /** 71 * Returns a {@code LongExpression} that wraps a 72 * {@link javafx.beans.value.ObservableLongValue}. If the 73 * {@code ObservableLongValue} is already a {@code LongExpression}, it will 74 * be returned. Otherwise a new {@link javafx.beans.binding.LongBinding} is 75 * created that is bound to the {@code ObservableLongValue}. 76 * 77 * @param value 78 * The source {@code ObservableLongValue} 79 * @return A {@code LongExpression} that wraps the 80 * {@code ObservableLongValue} if necessary 81 * @throws NullPointerException 82 * if {@code value} is {@code null} 83 */ 84 public static LongExpression longExpression(final ObservableLongValue value) { 85 if (value == null) { 86 throw new NullPointerException("Value must be specified."); 87 } 88 return (value instanceof LongExpression) ? (LongExpression) value 89 : new LongBinding() { 90 { 91 super.bind(value); 92 } 93 94 @Override 95 public void dispose() { 96 super.unbind(value); 97 } 98 99 @Override 100 protected long computeValue() { 101 return value.get(); 102 } 103 104 @Override 105 public ObservableList<ObservableLongValue> getDependencies() { 106 return FXCollections.singletonObservableList(value); 107 } 108 }; 109 } 110 111 /** 112 * Returns a {@code LongExpression} that wraps an 113 * {@link javafx.beans.value.ObservableValue}. If the 114 * {@code ObservableValue} is already a {@code LongExpression}, it 115 * will be returned. Otherwise a new 116 * {@link javafx.beans.binding.LongBinding} is created that is bound to 117 * the {@code ObservableValue}. 118 * 119 * <p> 120 * Note: this method can be used to convert an {@link ObjectExpression} or 121 * {@link javafx.beans.property.ObjectProperty} of specific number type to LongExpression, which 122 * is essentially an {@code ObservableValue<Number>}. See sample below. 123 * 124 * <blockquote><pre> 125 * LongProperty longProperty = new SimpleLongProperty(1L); 126 * ObjectProperty<Long> objectProperty = new SimpleObjectProperty<>(2L); 127 * BooleanBinding binding = longProperty.greaterThan(LongExpression.longExpression(objectProperty)); 128 * </pre></blockquote> 129 * 130 * Note: null values will be interpreted as 0L 131 * 132 * @param value 133 * The source {@code ObservableValue} 134 * @return A {@code LongExpression} that wraps the 135 * {@code ObservableValue} if necessary 136 * @throws NullPointerException 137 * if {@code value} is {@code null} 138 * @since JavaFX 8.0 139 */ 140 public static <T extends Number> LongExpression longExpression(final ObservableValue<T> value) { 141 if (value == null) { 142 throw new NullPointerException("Value must be specified."); 143 } 144 return (value instanceof LongExpression) ? (LongExpression) value 145 : new LongBinding() { 146 { 147 super.bind(value); 148 } 149 150 @Override 151 public void dispose() { 152 super.unbind(value); 153 } 154 155 @Override 156 protected long computeValue() { 157 final T val = value.getValue(); 158 return val == null ? 0L : val.longValue(); 159 } 160 161 @Override 162 public ObservableList<ObservableValue<T>> getDependencies() { 163 return FXCollections.singletonObservableList(value); 164 } 165 }; 166 } 167 168 169 @Override 170 public LongBinding negate() { 171 return (LongBinding) Bindings.negate(this); 172 } 173 174 @Override 175 public DoubleBinding add(final double other) { 176 return Bindings.add(this, other); 177 } 178 179 @Override 180 public FloatBinding add(final float other) { 181 return (FloatBinding) Bindings.add(this, other); 182 } 183 184 @Override 185 public LongBinding add(final long other) { 186 return (LongBinding) Bindings.add(this, other); 187 } 188 189 @Override 190 public LongBinding add(final int other) { 191 return (LongBinding) Bindings.add(this, other); 192 } 193 194 @Override 195 public DoubleBinding subtract(final double other) { 196 return Bindings.subtract(this, other); 197 } 198 199 @Override 200 public FloatBinding subtract(final float other) { 201 return (FloatBinding) Bindings.subtract(this, other); 202 } 203 204 @Override 205 public LongBinding subtract(final long other) { 206 return (LongBinding) Bindings.subtract(this, other); 207 } 208 209 @Override 210 public LongBinding subtract(final int other) { 211 return (LongBinding) Bindings.subtract(this, other); 212 } 213 214 @Override 215 public DoubleBinding multiply(final double other) { 216 return Bindings.multiply(this, other); 217 } 218 219 @Override 220 public FloatBinding multiply(final float other) { 221 return (FloatBinding) Bindings.multiply(this, other); 222 } 223 224 @Override 225 public LongBinding multiply(final long other) { 226 return (LongBinding) Bindings.multiply(this, other); 227 } 228 229 @Override 230 public LongBinding multiply(final int other) { 231 return (LongBinding) Bindings.multiply(this, other); 232 } 233 234 @Override 235 public DoubleBinding divide(final double other) { 236 return Bindings.divide(this, other); 237 } 238 239 @Override 240 public FloatBinding divide(final float other) { 241 return (FloatBinding) Bindings.divide(this, other); 242 } 243 244 @Override 245 public LongBinding divide(final long other) { 246 return (LongBinding) Bindings.divide(this, other); 247 } 248 249 @Override 250 public LongBinding divide(final int other) { 251 return (LongBinding) Bindings.divide(this, other); 252 } 253 254 /** 255 * Creates an {@link javafx.beans.binding.ObjectExpression} that holds the value 256 * of this {@code LongExpression}. If the 257 * value of this {@code LongExpression} changes, the value of the 258 * {@code ObjectExpression} will be updated automatically. 259 * 260 * @return the new {@code ObjectExpression} 261 * @since JavaFX 8.0 262 */ 263 public ObjectExpression<Long> asObject() { 264 return new ObjectBinding<Long>() { 265 { 266 bind(LongExpression.this); 267 } 268 269 @Override 270 public void dispose() { 271 unbind(LongExpression.this); 272 } 273 274 @Override 275 protected Long computeValue() { 276 return LongExpression.this.getValue(); 277 } 278 }; 279 } 280 }