From 65277b9a696b47e4e9c41a51c16d433ed7ea59b7 Mon Sep 17 00:00:00 2001 From: Mark Hiner Date: Sat, 16 Jan 2016 12:01:53 -0600 Subject: [PATCH] Refactor to use GenericLongType This provides a unified superclass for generic typing purposes when using LongType and UnsignedLongType. --- .../type/numeric/integer/GenericLongType.java | 239 ++++++++++++++++++ .../type/numeric/integer/LongType.java | 147 +---------- .../numeric/integer/UnsignedLongType.java | 64 ++--- 3 files changed, 262 insertions(+), 188 deletions(-) create mode 100644 src/main/java/net/imglib2/type/numeric/integer/GenericLongType.java diff --git a/src/main/java/net/imglib2/type/numeric/integer/GenericLongType.java b/src/main/java/net/imglib2/type/numeric/integer/GenericLongType.java new file mode 100644 index 0000000000..4418247eb7 --- /dev/null +++ b/src/main/java/net/imglib2/type/numeric/integer/GenericLongType.java @@ -0,0 +1,239 @@ +/* + * #%L + * ImgLib2: a general-purpose, multidimensional image processing library. + * %% + * Copyright (C) 2009 - 2015 Tobias Pietzsch, Stephan Preibisch, Barry DeZonia, + * Stephan Saalfeld, Curtis Rueden, Albert Cardona, Christian Dietz, Jean-Yves + * Tinevez, Johannes Schindelin, Jonathan Hale, Lee Kamentsky, Larry Lindsey, Mark + * Hiner, Michael Zinsmaier, Martin Horn, Grant Harris, Aivar Grislis, John + * Bogovic, Steffen Jaensch, Stefan Helfrich, Jan Funke, Nick Perry, Mark Longair, + * Melissa Linkert and Dimiter Prodanov. + * %% + * Redistribution and use in source and binary forms, with or without + * modification, are permitted provided that the following conditions are met: + * + * 1. Redistributions of source code must retain the above copyright notice, + * this list of conditions and the following disclaimer. + * 2. Redistributions in binary form must reproduce the above copyright notice, + * this list of conditions and the following disclaimer in the documentation + * and/or other materials provided with the distribution. + * + * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" + * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE + * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR CONTRIBUTORS BE + * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR + * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF + * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS + * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN + * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + * POSSIBILITY OF SUCH DAMAGE. + * #L% + */ +package net.imglib2.type.numeric.integer; + +import net.imglib2.img.NativeImg; +import net.imglib2.img.basictypeaccess.LongAccess; +import net.imglib2.img.basictypeaccess.array.LongArray; +import net.imglib2.type.NativeType; +import net.imglib2.util.Fraction; +import net.imglib2.util.Util; + +/** + * Abstract superclass for Long types. + * + * @author Mark Hiner hinerm at gmail.com + */ +public abstract class GenericLongType < T extends GenericLongType< T >> extends AbstractIntegerType< T > implements NativeType< T > { + + int i = 0; + + final protected NativeImg< T, ? extends LongAccess > img; + + // the DataAccess that holds the information + protected LongAccess dataAccess; + + // this is the constructor if you want it to read from an array + public GenericLongType( final NativeImg< T, ? extends LongAccess > longStorage ) + { + img = longStorage; + } + + // this is the constructor if you want it to be a variable + public GenericLongType( final long value ) + { + img = null; + dataAccess = new LongArray( 1 ); + setValue( value ); + } + + // this is the constructor if you want to specify the dataAccess + public GenericLongType( final LongAccess access ) + { + img = null; + dataAccess = access; + } + + // this is the constructor if you want it to be a variable + public GenericLongType() + { + this( 0 ); + } + + @Override + public Fraction getEntitiesPerPixel() { return new Fraction(); } + + @Override + public void updateContainer( final Object c ) + { + dataAccess = img.update( c ); + } + + protected long getValue() + { + return dataAccess.getValue( i ); + } + + protected void setValue( final long f ) + { + dataAccess.setValue( i, f ); + } + + + @Override + public void mul( final float c ) + { + setValue( Util.round( getValue() * c ) ); + } + + @Override + public void mul( final double c ) + { + setValue( Util.round( getValue() * c ) ); + } + + @Override + public void add( final T c ) + { + setValue( getValue() + c.getValue() ); + } + + @Override + public void div( final T c ) + { + setValue( getValue() / c.getValue() ); + } + + @Override + public void mul( final T c ) + { + setValue( getValue() * c.getValue() ); + } + + @Override + public void sub( final T c ) + { + setValue( getValue() - c.getValue() ); + } + + @Override + public int hashCode() + { + // NB: Use the same hash code as java.lang.Long#hashCode(). + return ( (Long)getValue() ).hashCode(); + } + + @Override + public int compareTo( final T c ) + { + final long a = getValue(); + final long b = c.getValue(); + if ( a > b ) + return 1; + else if ( a < b ) + return -1; + else + return 0; + } + + @Override + public void set( final T c ) + { + setValue( c.getValue() ); + } + + @Override + public void setOne() + { + setValue( 1 ); + } + + @Override + public void setZero() + { + setValue( 0 ); + } + + @Override + public void inc() + { + long a = getValue(); + setValue( ++a ); + } + + @Override + public void dec() + { + long a = getValue(); + setValue( --a ); + } + + @Override + public String toString() + { + return "" + getValue(); + } + + @Override + public void updateIndex( final int index ) + { + i = index; + } + + @Override + public int getIndex() + { + return i; + } + + @Override + public void incIndex() + { + ++i; + } + + @Override + public void incIndex( final int increment ) + { + i += increment; + } + + @Override + public void decIndex() + { + --i; + } + + @Override + public void decIndex( final int decrement ) + { + i -= decrement; + } + + @Override + public int getBitsPerPixel() + { + return 64; + } +} diff --git a/src/main/java/net/imglib2/type/numeric/integer/LongType.java b/src/main/java/net/imglib2/type/numeric/integer/LongType.java index c0981794aa..878ef3f908 100644 --- a/src/main/java/net/imglib2/type/numeric/integer/LongType.java +++ b/src/main/java/net/imglib2/type/numeric/integer/LongType.java @@ -39,51 +39,39 @@ import net.imglib2.img.NativeImg; import net.imglib2.img.NativeImgFactory; import net.imglib2.img.basictypeaccess.LongAccess; -import net.imglib2.img.basictypeaccess.array.LongArray; -import net.imglib2.type.NativeType; import net.imglib2.util.Fraction; -import net.imglib2.util.Util; /** * TODO * * @author Stephan Preibisch * @author Stephan Saalfeld + * @author Mark Hiner */ -final public class LongType extends AbstractIntegerType< LongType > implements NativeType< LongType > +final public class LongType extends GenericLongType { - private int i = 0; - - final protected NativeImg< ?, ? extends LongAccess > img; - - // the DataAccess that holds the information - protected LongAccess dataAccess; - // this is the constructor if you want it to read from an array - public LongType( final NativeImg< ?, ? extends LongAccess > longStorage ) + public LongType( final NativeImg< LongType, ? extends LongAccess > longStorage ) { - img = longStorage; + super( longStorage ); } // this is the constructor if you want to specify the dataAccess public LongType( final LongAccess access ) { - img = null; - dataAccess = access; + super ( access ); } // this is the constructor if you want it to be a variable public LongType( final long value ) { - img = null; - dataAccess = new LongArray( 1 ); - set( value ); + super( value ); } // this is the constructor if you want it to be a variable public LongType() { - this( 0 ); + super( 0 ); } @Override @@ -101,12 +89,6 @@ public LongType() return container; } - @Override - public void updateContainer( final Object c ) - { - dataAccess = img.update( c ); - } - @Override public LongType duplicateTypeOnSameNativeImg() { @@ -154,7 +136,7 @@ public void setInteger( final long f ) } @Override - public void setBigInteger(BigInteger b) + public void setBigInteger( BigInteger b ) { set( b.longValue() ); } @@ -171,42 +153,6 @@ public double getMinValue() return Long.MIN_VALUE; } - @Override - public void mul( final float c ) - { - set( Util.round( get() * c ) ); - } - - @Override - public void mul( final double c ) - { - set( Util.round( get() * c ) ); - } - - @Override - public void add( final LongType c ) - { - set( get() + c.get() ); - } - - @Override - public void div( final LongType c ) - { - set( get() / c.get() ); - } - - @Override - public void mul( final LongType c ) - { - set( get() * c.get() ); - } - - @Override - public void sub( final LongType c ) - { - set( get() - c.get() ); - } - @Override public int hashCode() { @@ -228,38 +174,6 @@ else if ( a < b ) return 0; } - @Override - public void set( final LongType c ) - { - set( c.get() ); - } - - @Override - public void setOne() - { - set( 1 ); - } - - @Override - public void setZero() - { - set( 0 ); - } - - @Override - public void inc() - { - long a = get(); - set( ++a ); - } - - @Override - public void dec() - { - long a = get(); - set( --a ); - } - @Override public LongType createVariable() { @@ -271,49 +185,4 @@ public LongType copy() { return new LongType( get() ); } - - @Override - public Fraction getEntitiesPerPixel() { return new Fraction(); } - - @Override - public void updateIndex( final int index ) - { - this.i = index; - } - - @Override - public int getIndex() - { - return i; - } - - @Override - public void incIndex() - { - ++i; - } - - @Override - public void incIndex( final int increment ) - { - i += increment; - } - - @Override - public void decIndex() - { - --i; - } - - @Override - public void decIndex( final int decrement ) - { - i -= decrement; - } - - @Override - public int getBitsPerPixel() - { - return 64; - } } diff --git a/src/main/java/net/imglib2/type/numeric/integer/UnsignedLongType.java b/src/main/java/net/imglib2/type/numeric/integer/UnsignedLongType.java index 8d9e37b946..8ed1043b85 100644 --- a/src/main/java/net/imglib2/type/numeric/integer/UnsignedLongType.java +++ b/src/main/java/net/imglib2/type/numeric/integer/UnsignedLongType.java @@ -40,7 +40,6 @@ import net.imglib2.img.NativeImgFactory; import net.imglib2.img.basictypeaccess.LongAccess; import net.imglib2.img.basictypeaccess.array.LongArray; -import net.imglib2.type.NativeType; import net.imglib2.util.Fraction; import net.imglib2.util.Util; @@ -50,34 +49,26 @@ * @author Stephan Preibisch * @author Stephan Saalfeld * @author Albert Cardona + * @author Mark Hiner */ -public class UnsignedLongType extends AbstractIntegerType implements NativeType +public class UnsignedLongType extends GenericLongType { - private int i = 0; - - final protected NativeImg img; - - // the DataAccess that holds the information - protected LongAccess dataAccess; - // this is the constructor if you want it to read from an array public UnsignedLongType( final NativeImg img ) { - this.img = img; + super( img ); } // this is the constructor if you want it to be a variable public UnsignedLongType( final long value ) { - img = null; - dataAccess = new LongArray( 1 ); - set( value ); + super( value ); } // this is the constructor if you want it to be a variable public UnsignedLongType ( final BigInteger value ) { - img = null; + super( ( NativeImg )null ); dataAccess = new LongArray ( 1 ); set( value.longValue() ); } @@ -85,8 +76,7 @@ public UnsignedLongType ( final BigInteger value ) // this is the constructor if you want to specify the dataAccess public UnsignedLongType( final LongAccess access ) { - img = null; - dataAccess = access; + super( access ); } // this is the constructor if you want it to be a variable @@ -181,7 +171,15 @@ public void sub( final UnsignedLongType c ) { set( get() - c.get() ); } - + + @Override + public int hashCode() + { + // NB: Use the same hash code as java.lang.Long#hashCode(). + final long value = get(); + return (int) (value ^ (value >>> 32)); + } + @Override public void setOne() { set( 1 ); } @@ -278,36 +276,4 @@ static public final int compare( final long a, final long b ) { @Override public UnsignedLongType copy() { return new UnsignedLongType( get() ); } - - @Override - public int getBitsPerPixel() { - return 64; - } - - @Override - public Fraction getEntitiesPerPixel() { - return new Fraction(); - } - - @Override - public void updateContainer( final Object c ) { dataAccess = img.update( c ); } - - - @Override - public void updateIndex( final int index ) { i = index; } - - @Override - public int getIndex() { return i; } - - @Override - public void incIndex() { ++i; } - - @Override - public void incIndex( final int increment ) { i += increment; } - - @Override - public void decIndex() { --i; } - - @Override - public void decIndex( final int decrement ) { i -= decrement; } }