X-Git-Url: https://gerrit.simantics.org/r/gitweb?a=blobdiff_plain;ds=sidebyside;f=bundles%2Forg.simantics.databoard%2Fsrc%2Forg%2Fsimantics%2Fdataboard%2Fprimitives%2FUnsignedInteger.java;fp=bundles%2Forg.simantics.databoard%2Fsrc%2Forg%2Fsimantics%2Fdataboard%2Fprimitives%2FUnsignedInteger.java;h=35523e45eef4070bd5343181fdcc0ad0508b9529;hb=969bd23cab98a79ca9101af33334000879fb60c5;hp=0000000000000000000000000000000000000000;hpb=866dba5cd5a3929bbeae85991796acb212338a08;p=simantics%2Fplatform.git

diff --git a/bundles/org.simantics.databoard/src/org/simantics/databoard/primitives/UnsignedInteger.java b/bundles/org.simantics.databoard/src/org/simantics/databoard/primitives/UnsignedInteger.java
new file mode 100644
index 000000000..35523e45e
--- /dev/null
+++ b/bundles/org.simantics.databoard/src/org/simantics/databoard/primitives/UnsignedInteger.java
@@ -0,0 +1,179 @@
+package org.simantics.databoard.primitives;
+
+
+/**
+ * Unsigned 32-bit integer value, either mutable or immutable. 
+ * The value is between 0 and 4294967295.
+ * 
+ * Example use: 
+ *    UnsignedInteger x = new UnsignedInteger.Mutable(); 
+ *    UnsignedInteger y = new UnsignedInteger.Immutable(4); 
+ *    UnsignedInteger z = UnsingedInteger.valueOf(5);
+ *
+ * @author Toni Kalajainen <toni.kalajainen@iki.fi>
+ */
+public abstract class UnsignedInteger extends Number implements Comparable<Number> {
+
+	private static final long serialVersionUID = 1L;
+
+	public static final UnsignedInteger MIN_VALUE, MAX_VALUE, ZERO;
+	
+	static long MASK = 0xFFFFFFFFl;
+	public static final long L_MAX_VALUE = 0xFFFFFFFFL;
+	public static final long L_MIN_VALUE = 0;
+
+	/** Value container */
+	int value;
+	
+    public static UnsignedInteger fromBits(int intBits) {
+		if (intBits>=0 && intBits<CACHE.length)	return CACHE[intBits];
+		return UnsignedInteger.Immutable.fromBits(intBits);
+    }	
+
+    public static UnsignedInteger valueOf(long value) {
+		if ( value>=0 && value<CACHE.length ) return CACHE[(int)value];
+    	if ( value<L_MIN_VALUE || value>L_MAX_VALUE ) throw new IllegalArgumentException("Argument is not within range");		
+		return new Immutable(value);    	
+    }
+	
+	public static class Mutable extends UnsignedInteger {
+
+		private static final long serialVersionUID = 1L;
+
+		public Mutable() {}
+		
+		/**
+		 * Create new unsigned integer from a signed integer.
+		 * Use #fromBits() to make bitwise conversion
+		 * 
+		 * @param value signed integer
+		 * @throws IllegalArgumentException if argument is sub zero
+		 */
+	    public Mutable(int value) throws IllegalArgumentException {
+	    	if ( value<L_MIN_VALUE || value>L_MAX_VALUE ) throw new IllegalArgumentException("Argument is not within range");
+	        this.value = value;
+	    }
+
+	    public Mutable(long value) throws IllegalArgumentException {
+	    	if ( value<L_MIN_VALUE || value>L_MAX_VALUE ) throw new IllegalArgumentException("Argument is not within range");
+	        this.value = (int) value;
+	    }
+
+	    public Mutable(String stringValue) throws IllegalArgumentException {
+	        long value = Long.parseLong(stringValue);
+	    	if ( value<L_MIN_VALUE || value>L_MAX_VALUE ) throw new IllegalArgumentException("Argument is not within range");
+	        this.value = (int) value;
+	    }	
+	    
+	    public static UnsignedInteger fromBits(int intBits) {
+	    	Mutable result = new Mutable();
+	    	result.value = intBits;
+	    	return result;
+	    }	
+	    
+	    public void setBits(int intBits) {
+	    	this.value = intBits;
+	    }
+	    
+	    public void setValue(int value) {
+	    	if ( value<L_MIN_VALUE || value>L_MAX_VALUE ) throw new IllegalArgumentException("Argument is not within range");
+	    	this.value = value;
+	    }
+	    
+	    public void setValue(long value) {
+	    	if ( value<L_MIN_VALUE || value>L_MAX_VALUE ) throw new IllegalArgumentException("Argument is not within range");
+	        this.value = (int) value;
+	    }	    
+		
+	}
+	
+	public final static class Immutable extends UnsignedInteger {
+
+		private static final long serialVersionUID = 1L;	
+
+		Immutable() {}
+		
+		/**
+		 * Create new unsigned integer from a signed integer.
+		 * Use #fromBits() to make bitwise conversion
+		 * 
+		 * @param value signed integer
+		 * @throws IllegalArgumentException if argument is sub zero
+		 */
+	    public Immutable(int value) throws IllegalArgumentException {
+	    	if ( value<L_MIN_VALUE || value>L_MAX_VALUE ) throw new IllegalArgumentException("Argument is not within range");
+	        this.value = value;
+	    }
+
+	    public Immutable(long value) throws IllegalArgumentException {
+	    	if ( value<L_MIN_VALUE || value>L_MAX_VALUE ) throw new IllegalArgumentException("Argument is not within range");
+	        this.value = (int) value;
+	    }
+
+	    public Immutable(String stringValue) throws IllegalArgumentException {
+	        long value = Long.parseLong(stringValue);
+	    	if ( value<L_MIN_VALUE || value>L_MAX_VALUE ) throw new IllegalArgumentException("Argument is not within range");
+	        this.value = (int) value;
+	    }	
+	    			    
+	}	
+	    
+    public int toBits() {
+    	return value;
+    }
+	
+	@Override
+	public int intValue() {
+		return value;
+	}
+	
+	@Override
+	public long longValue() {
+		return value & MASK;
+	}
+	
+	@Override
+	public float floatValue() {
+		return value & MASK;
+	}
+	@Override
+	public double doubleValue() {
+		return value & MASK;
+	}
+	
+    @Override
+	public boolean equals(Object obj) {
+		if (obj == null) return false;
+		if (obj == this) return true;
+		
+		if (obj instanceof UnsignedInteger == false) return false;
+		UnsignedInteger other = (UnsignedInteger) obj;
+		return value == other.value;
+	}
+    
+    @Override
+    public String toString() {
+        return Long.toString(value & MASK);
+    }
+    
+	@Override
+	public int compareTo(Number obj) {
+        return Long.signum( (value & MASK) - obj.longValue() );
+	}
+	
+	@Override
+	public int hashCode() {
+		return value;
+	}
+
+	// Initialize Cache
+	private static int CACHE_SIZE = 16;
+	private static UnsignedInteger.Immutable[] CACHE;
+	static {
+		CACHE = new UnsignedInteger.Immutable[CACHE_SIZE];
+		for (int i=0; i<CACHE_SIZE; i++) CACHE[i] = new UnsignedInteger.Immutable(i);
+		ZERO = MIN_VALUE = CACHE[0];
+		MAX_VALUE = new UnsignedInteger.Immutable(L_MAX_VALUE);
+	}		    
+	
+}