diff --git a/community/values/src/main/java/org/neo4j/values/DirectArray.java b/community/values/src/main/java/org/neo4j/values/DirectArray.java index 119a2564fdcb..512a9f7c5a39 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectArray.java @@ -19,24 +19,24 @@ */ package org.neo4j.values; -abstract class DirectArray extends Value +abstract class DirectArray extends ValueImpl { abstract int length(); @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return false; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return false; } diff --git a/community/values/src/main/java/org/neo4j/values/DirectBoolean.java b/community/values/src/main/java/org/neo4j/values/DirectBoolean.java index 849ac8a347db..170f9aed0efb 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectBoolean.java +++ b/community/values/src/main/java/org/neo4j/values/DirectBoolean.java @@ -47,19 +47,19 @@ public boolean equals( Value other ) } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return bool == x; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return false; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return false; } @@ -83,11 +83,17 @@ public int compareTo( ValueGroup.VBoolean other ) } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { writer.writeBoolean( bool ); } + @Override + public Object asPublic() + { + return bool; + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectBooleanArray.java b/community/values/src/main/java/org/neo4j/values/DirectBooleanArray.java index dbda8b463468..7bc34d4d7d0b 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectBooleanArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectBooleanArray.java @@ -58,55 +58,55 @@ public boolean equals( Value other ) } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return false; } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return false; } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return false; } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return false; } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return false; } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return false; } @Override - boolean equals( boolean[] x ) + public boolean equals( boolean[] x ) { return Arrays.equals( value, x ); } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return false; } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return false; } @@ -118,11 +118,17 @@ public int hashCode() } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, value ); } + @Override + public Object asPublic() + { + return value.clone(); + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectByte.java b/community/values/src/main/java/org/neo4j/values/DirectByte.java index 1fc79bd798d0..f16328bd0faa 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectByte.java +++ b/community/values/src/main/java/org/neo4j/values/DirectByte.java @@ -41,29 +41,35 @@ public long longValue() } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return false; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return false; } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { writer.writeInteger( value ); } + @Override + public Object asPublic() + { + return value; + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectByteArray.java b/community/values/src/main/java/org/neo4j/values/DirectByteArray.java index 3f22285d8fca..2b053b7055d4 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectByteArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectByteArray.java @@ -46,47 +46,53 @@ public long longValue( int index ) } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return Arrays.equals( value, x ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, value ); } + @Override + public Object asPublic() + { + return value.clone(); + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectChar.java b/community/values/src/main/java/org/neo4j/values/DirectChar.java index 7aca194beadb..c720e86461c4 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectChar.java +++ b/community/values/src/main/java/org/neo4j/values/DirectChar.java @@ -43,19 +43,19 @@ public boolean equals( Value other ) } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return value == x; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return x.length() == 1 && x.charAt( 0 ) == value; } @@ -67,11 +67,17 @@ public int hashCode() } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { writer.writeString( value ); } + @Override + public Object asPublic() + { + return value; + } + @Override public String stringValue() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectCharArray.java b/community/values/src/main/java/org/neo4j/values/DirectCharArray.java index b5f785b8bc29..b010baf26e47 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectCharArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectCharArray.java @@ -23,7 +23,7 @@ import static java.lang.String.format; -final class DirectCharArray extends DirectArray implements ValueGroup.VTextArray +final class DirectCharArray extends DirectTextArray { final char[] value; @@ -45,48 +45,6 @@ public boolean equals( Value other ) return other.equals( value ); } - @Override - boolean equals( byte[] x ) - { - return false; - } - - @Override - boolean equals( short[] x ) - { - return false; - } - - @Override - boolean equals( int[] x ) - { - return false; - } - - @Override - boolean equals( long[] x ) - { - return false; - } - - @Override - boolean equals( float[] x ) - { - return false; - } - - @Override - boolean equals( double[] x ) - { - return false; - } - - @Override - boolean equals( boolean[] x ) - { - return false; - } - // TODO: should we support this? // @Override // boolean equals( String x ) @@ -95,13 +53,13 @@ boolean equals( boolean[] x ) // } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return Arrays.equals( value, x ); } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return PrimitiveArrayValues.equals( value, x ); } @@ -131,11 +89,17 @@ public String stringValue( int offset ) } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, value ); } + @Override + public Object asPublic() + { + return value.clone(); + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectDouble.java b/community/values/src/main/java/org/neo4j/values/DirectDouble.java index 40b10a24647f..926a990885a8 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectDouble.java +++ b/community/values/src/main/java/org/neo4j/values/DirectDouble.java @@ -37,29 +37,35 @@ public double doubleValue() } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return false; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return false; } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { writer.writeFloatingPoint( value ); } + @Override + public Object asPublic() + { + return value; + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectDoubleArray.java b/community/values/src/main/java/org/neo4j/values/DirectDoubleArray.java index 058114b41143..e4d6c7ce2914 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectDoubleArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectDoubleArray.java @@ -46,47 +46,53 @@ public double doubleValue( int index ) } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return Arrays.equals( x, value ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, value ); } + @Override + public Object asPublic() + { + return value.clone(); + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectFloat.java b/community/values/src/main/java/org/neo4j/values/DirectFloat.java index f1fc5bd0af59..ae9ddc63f43f 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectFloat.java +++ b/community/values/src/main/java/org/neo4j/values/DirectFloat.java @@ -37,29 +37,35 @@ public double doubleValue() } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return false; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return false; } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { writer.writeFloatingPoint( value ); } + @Override + public Object asPublic() + { + return value; + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectFloatArray.java b/community/values/src/main/java/org/neo4j/values/DirectFloatArray.java index 9a8e9190b4d2..ed2910318156 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectFloatArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectFloatArray.java @@ -46,47 +46,53 @@ public double doubleValue( int index ) } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return Arrays.equals( value, x ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, value ); } + @Override + public Object asPublic() + { + return value.clone(); + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectFloatingPointArray.java b/community/values/src/main/java/org/neo4j/values/DirectFloatingPointArray.java index f70debc3a999..c4fd970e80bb 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectFloatingPointArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectFloatingPointArray.java @@ -24,19 +24,19 @@ abstract class DirectFloatingPointArray extends DirectArray implements ValueGrou public abstract double doubleValue( int index ); @Override - boolean equals( boolean[] x ) + public boolean equals( boolean[] x ) { return false; } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return false; } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return false; } @@ -48,7 +48,7 @@ public boolean equals( Object other ) } @Override - final boolean equals( Value other ) + public final boolean equals( Value other ) { if ( other instanceof ValueGroup.VFloatingPointArray ) { diff --git a/community/values/src/main/java/org/neo4j/values/DirectInt.java b/community/values/src/main/java/org/neo4j/values/DirectInt.java index a3a15a419126..b640778ed616 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectInt.java +++ b/community/values/src/main/java/org/neo4j/values/DirectInt.java @@ -37,29 +37,35 @@ public long longValue() } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return false; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return false; } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { writer.writeInteger( value ); } + @Override + public Object asPublic() + { + return value; + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectIntArray.java b/community/values/src/main/java/org/neo4j/values/DirectIntArray.java index 84faf879b0ee..3382b688d614 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectIntArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectIntArray.java @@ -46,47 +46,53 @@ public long longValue( int index ) } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return Arrays.equals( value, x ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, value ); } + @Override + public Object asPublic() + { + return value.clone(); + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectIntegralArray.java b/community/values/src/main/java/org/neo4j/values/DirectIntegralArray.java index 4d9d97633ff8..a98167e74fe2 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectIntegralArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectIntegralArray.java @@ -22,19 +22,19 @@ abstract class DirectIntegralArray extends DirectArray implements ValueGroup.VIntegerArray { @Override - boolean equals( boolean[] x ) + public boolean equals( boolean[] x ) { return false; } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return false; } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return false; } @@ -46,7 +46,7 @@ public boolean equals( Object other ) } @Override - final boolean equals( Value other ) + public final boolean equals( Value other ) { if ( other instanceof ValueGroup.VIntegerArray ) { diff --git a/community/values/src/main/java/org/neo4j/values/DirectLong.java b/community/values/src/main/java/org/neo4j/values/DirectLong.java index 90ed00e743a0..dcc1e4d9b4d8 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectLong.java +++ b/community/values/src/main/java/org/neo4j/values/DirectLong.java @@ -37,29 +37,35 @@ public long longValue() } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return false; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return false; } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { writer.writeInteger( value ); } + @Override + public Object asPublic() + { + return value; + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectLongArray.java b/community/values/src/main/java/org/neo4j/values/DirectLongArray.java index 8c704c822328..374b669f25ad 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectLongArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectLongArray.java @@ -46,47 +46,53 @@ public long longValue( int index ) } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return Arrays.equals( value, x ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, value ); } + @Override + public Object asPublic() + { + return value; + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectScalar.java b/community/values/src/main/java/org/neo4j/values/DirectScalar.java index c32d093d5931..1747440028ea 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectScalar.java +++ b/community/values/src/main/java/org/neo4j/values/DirectScalar.java @@ -19,58 +19,58 @@ */ package org.neo4j.values; -abstract class DirectScalar extends Value +abstract class DirectScalar extends ValueImpl { @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return false; } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return false; } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return false; } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return false; } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return false; } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return false; } @Override - boolean equals( boolean[] x ) + public boolean equals( boolean[] x ) { return false; } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return false; } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return false; } diff --git a/community/values/src/main/java/org/neo4j/values/DirectShort.java b/community/values/src/main/java/org/neo4j/values/DirectShort.java index 84717639ade1..764c01e75909 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectShort.java +++ b/community/values/src/main/java/org/neo4j/values/DirectShort.java @@ -41,29 +41,35 @@ public long longValue() } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return false; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return false; } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { writer.writeInteger( value ); } + @Override + public Object asPublic() + { + return value; + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectShortArray.java b/community/values/src/main/java/org/neo4j/values/DirectShortArray.java index 59aad840cd8d..481739bb759b 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectShortArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectShortArray.java @@ -46,47 +46,53 @@ public long longValue( int index ) } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return Arrays.equals( value, x ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return PrimitiveArrayValues.equals( value, x ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, value ); } + @Override + public Object asPublic() + { + return value.clone(); + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectString.java b/community/values/src/main/java/org/neo4j/values/DirectString.java index f1d07c954035..f0679c327069 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectString.java +++ b/community/values/src/main/java/org/neo4j/values/DirectString.java @@ -44,19 +44,19 @@ public boolean equals( Value value ) } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return string.length() == 1 && string.charAt( 0 ) == x; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return string.equals( x ); } @@ -68,11 +68,17 @@ public int hashCode() } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { writer.writeString( string ); } + @Override + public Object asPublic() + { + return string; + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectStringArray.java b/community/values/src/main/java/org/neo4j/values/DirectStringArray.java index 90c2beb0bedc..bae85bab7470 100644 --- a/community/values/src/main/java/org/neo4j/values/DirectStringArray.java +++ b/community/values/src/main/java/org/neo4j/values/DirectStringArray.java @@ -23,7 +23,7 @@ import static java.lang.String.format; -final class DirectStringArray extends DirectArray implements ValueGroup.VTextArray +final class DirectStringArray extends DirectTextArray { final String[] value; @@ -58,55 +58,13 @@ public boolean equals( Value other ) } @Override - boolean equals( byte[] x ) - { - return false; - } - - @Override - boolean equals( short[] x ) - { - return false; - } - - @Override - boolean equals( int[] x ) - { - return false; - } - - @Override - boolean equals( long[] x ) - { - return false; - } - - @Override - boolean equals( float[] x ) - { - return false; - } - - @Override - boolean equals( double[] x ) - { - return false; - } - - @Override - boolean equals( boolean[] x ) - { - return false; - } - - @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return PrimitiveArrayValues.equals( x, value ); } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return Arrays.equals( value, x ); } @@ -118,11 +76,17 @@ public int hashCode() } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, value ); } + @Override + public Object asPublic() + { + return value.clone(); + } + @Override public String toString() { diff --git a/community/values/src/main/java/org/neo4j/values/DirectTextArray.java b/community/values/src/main/java/org/neo4j/values/DirectTextArray.java new file mode 100644 index 000000000000..d4e7f3878159 --- /dev/null +++ b/community/values/src/main/java/org/neo4j/values/DirectTextArray.java @@ -0,0 +1,66 @@ +/* + * Copyright (c) 2002-2017 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.values; + +abstract class DirectTextArray extends DirectArray implements ValueGroup.VTextArray +{ + @Override + public boolean equals( byte[] x ) + { + return false; + } + + @Override + public boolean equals( short[] x ) + { + return false; + } + + @Override + public boolean equals( int[] x ) + { + return false; + } + + @Override + public boolean equals( long[] x ) + { + return false; + } + + @Override + public boolean equals( float[] x ) + { + return false; + } + + @Override + public boolean equals( double[] x ) + { + return false; + } + + @Override + public boolean equals( boolean[] x ) + { + return false; + } + +} diff --git a/community/values/src/main/java/org/neo4j/values/LazyArray.java b/community/values/src/main/java/org/neo4j/values/LazyArray.java index 7b3ec9e19b95..f432e7dfa34b 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyArray.java @@ -29,19 +29,19 @@ abstract class LazyArray extends LazyValue } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return false; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return false; } diff --git a/community/values/src/main/java/org/neo4j/values/LazyBooleanArray.java b/community/values/src/main/java/org/neo4j/values/LazyBooleanArray.java index 726e74a7d37a..6610615c4ff5 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyBooleanArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyBooleanArray.java @@ -42,55 +42,55 @@ public boolean equals( Value other ) } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return false; } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return false; } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return false; } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return false; } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return false; } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return false; } @Override - boolean equals( boolean[] x ) + public boolean equals( boolean[] x ) { return Arrays.equals( getOrLoad(), x ); } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return false; } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return false; } @@ -102,11 +102,17 @@ public int hashCode() } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, getOrLoad() ); } + @Override + public Object asPublic() + { + return getOrLoad().clone(); + } + @Override public int length() { diff --git a/community/values/src/main/java/org/neo4j/values/LazyByteArray.java b/community/values/src/main/java/org/neo4j/values/LazyByteArray.java index df56a2d73b9b..d2e0643caa55 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyByteArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyByteArray.java @@ -22,7 +22,7 @@ import java.util.Arrays; import java.util.concurrent.Callable; -public class LazyByteArray extends LazyIntegralArray +final class LazyByteArray extends LazyIntegralArray { LazyByteArray( Callable producer ) { @@ -42,53 +42,59 @@ public boolean equals( Object other ) } @Override - boolean equals( Value other ) + public boolean equals( Value other ) { return other.equals( getOrLoad() ); } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return Arrays.equals( x, getOrLoad() ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, getOrLoad() ); } + @Override + public Object asPublic() + { + return getOrLoad().clone(); + } + @Override public int length() { diff --git a/community/values/src/main/java/org/neo4j/values/LazyCharArray.java b/community/values/src/main/java/org/neo4j/values/LazyCharArray.java index 9d439ba7a58f..603131b03f85 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyCharArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyCharArray.java @@ -22,7 +22,7 @@ import java.util.Arrays; import java.util.concurrent.Callable; -public class LazyCharArray extends LazyTextArray +final class LazyCharArray extends LazyTextArray { LazyCharArray( Callable producer ) { @@ -42,19 +42,19 @@ public boolean equals( Object other ) } @Override - boolean equals( Value other ) + public boolean equals( Value other ) { return other.equals( getOrLoad() ); } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return Arrays.equals( getOrLoad(), x ); } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @@ -66,11 +66,17 @@ public int compareTo( ValueGroup.VTextArray other ) } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, getOrLoad() ); } + @Override + public Object asPublic() + { + return getOrLoad().clone(); + } + @Override public int length() { diff --git a/community/values/src/main/java/org/neo4j/values/LazyDoubleArray.java b/community/values/src/main/java/org/neo4j/values/LazyDoubleArray.java index 63f94709897e..8cc0606d16d5 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyDoubleArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyDoubleArray.java @@ -22,7 +22,7 @@ import java.util.Arrays; import java.util.concurrent.Callable; -public class LazyDoubleArray extends LazyFloatingPointArray +final class LazyDoubleArray extends LazyFloatingPointArray { LazyDoubleArray( Callable producer ) { @@ -42,53 +42,59 @@ public boolean equals( Object other ) } @Override - boolean equals( Value other ) + public boolean equals( Value other ) { return other.equals( getOrLoad() ); } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return Arrays.equals( getOrLoad(), x ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, getOrLoad() ); } + @Override + public Object asPublic() + { + return getOrLoad().clone(); + } + @Override public int length() { diff --git a/community/values/src/main/java/org/neo4j/values/LazyFloatArray.java b/community/values/src/main/java/org/neo4j/values/LazyFloatArray.java index d04b45a568b5..34a42113f73e 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyFloatArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyFloatArray.java @@ -22,7 +22,7 @@ import java.util.Arrays; import java.util.concurrent.Callable; -public class LazyFloatArray extends LazyFloatingPointArray +final class LazyFloatArray extends LazyFloatingPointArray { LazyFloatArray( Callable producer ) { @@ -42,53 +42,59 @@ public boolean equals( Object other ) } @Override - boolean equals( Value other ) + public boolean equals( Value other ) { return other.equals( getOrLoad() ); } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return Arrays.equals( getOrLoad(), x ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, getOrLoad() ); } + @Override + public Object asPublic() + { + return getOrLoad().clone(); + } + @Override public int length() { diff --git a/community/values/src/main/java/org/neo4j/values/LazyFloatingPointArray.java b/community/values/src/main/java/org/neo4j/values/LazyFloatingPointArray.java index e2f2509cf807..c3689c80774d 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyFloatingPointArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyFloatingPointArray.java @@ -29,19 +29,19 @@ abstract class LazyFloatingPointArray extends LazyArray implements ValueGr } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return false; } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return false; } @Override - boolean equals( boolean[] x ) + public boolean equals( boolean[] x ) { return false; } diff --git a/community/values/src/main/java/org/neo4j/values/LazyIntArray.java b/community/values/src/main/java/org/neo4j/values/LazyIntArray.java index c3c398e8860a..a4af73248ba0 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyIntArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyIntArray.java @@ -22,7 +22,7 @@ import java.util.Arrays; import java.util.concurrent.Callable; -public class LazyIntArray extends LazyIntegralArray +final class LazyIntArray extends LazyIntegralArray { LazyIntArray( Callable producer ) { @@ -42,53 +42,59 @@ public boolean equals( Object other ) } @Override - boolean equals( Value other ) + public boolean equals( Value other ) { return other.equals( getOrLoad() ); } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return Arrays.equals( getOrLoad(), x ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, getOrLoad() ); } + @Override + public Object asPublic() + { + return getOrLoad().clone(); + } + @Override public int length() { diff --git a/community/values/src/main/java/org/neo4j/values/LazyIntegralArray.java b/community/values/src/main/java/org/neo4j/values/LazyIntegralArray.java index f5bd836589bc..907a9114ce63 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyIntegralArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyIntegralArray.java @@ -29,19 +29,19 @@ abstract class LazyIntegralArray extends LazyArray implements ValueGroup.V } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return false; } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return false; } @Override - boolean equals( boolean[] x ) + public boolean equals( boolean[] x ) { return false; } diff --git a/community/values/src/main/java/org/neo4j/values/LazyLongArray.java b/community/values/src/main/java/org/neo4j/values/LazyLongArray.java index e6fc546058d2..b6d7bd96cb1c 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyLongArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyLongArray.java @@ -22,7 +22,7 @@ import java.util.Arrays; import java.util.concurrent.Callable; -public class LazyLongArray extends LazyIntegralArray +final class LazyLongArray extends LazyIntegralArray { LazyLongArray( Callable producer ) { @@ -42,53 +42,59 @@ public boolean equals( Object other ) } @Override - boolean equals( Value other ) + public boolean equals( Value other ) { return other.equals( getOrLoad() ); } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return Arrays.equals( getOrLoad(), x ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, getOrLoad() ); } + @Override + public Object asPublic() + { + return getOrLoad().clone(); + } + @Override public int length() { diff --git a/community/values/src/main/java/org/neo4j/values/LazyShortArray.java b/community/values/src/main/java/org/neo4j/values/LazyShortArray.java index cfb1c894a31e..9181848a471e 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyShortArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyShortArray.java @@ -22,7 +22,7 @@ import java.util.Arrays; import java.util.concurrent.Callable; -public class LazyShortArray extends LazyIntegralArray +final class LazyShortArray extends LazyIntegralArray { LazyShortArray( Callable producer ) { @@ -42,53 +42,59 @@ public boolean equals( Object other ) } @Override - boolean equals( Value other ) + public boolean equals( Value other ) { return other.equals( getOrLoad() ); } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return Arrays.equals( getOrLoad(), x ); } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return PrimitiveArrayValues.equals( getOrLoad(), x ); } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, getOrLoad() ); } + @Override + public Object asPublic() + { + return getOrLoad().clone(); + } + @Override public int length() { diff --git a/community/values/src/main/java/org/neo4j/values/LazyString.java b/community/values/src/main/java/org/neo4j/values/LazyString.java index 537aaddc55bb..c8830c16204c 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyString.java +++ b/community/values/src/main/java/org/neo4j/values/LazyString.java @@ -23,7 +23,7 @@ import static java.lang.String.format; -class LazyString extends LazyValue implements ValueGroup.VText +final class LazyString extends LazyValue implements ValueGroup.VText { LazyString( Callable producer ) { @@ -43,84 +43,90 @@ public boolean equals( Value value ) } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return false; } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return false; } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return false; } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return false; } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return false; } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return false; } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( boolean[] x ) + public boolean equals( boolean[] x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return false; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return getOrLoad().equals( x ); } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { // TODO: do we want to support this? return false; } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return false; } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { writer.writeString( getOrLoad() ); } + @Override + public Object asPublic() + { + return getOrLoad(); + } + @Override public int hashCode() { diff --git a/community/values/src/main/java/org/neo4j/values/LazyStringArray.java b/community/values/src/main/java/org/neo4j/values/LazyStringArray.java index bef02b7aa0b2..492bc28b0a3a 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyStringArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyStringArray.java @@ -22,7 +22,7 @@ import java.util.Arrays; import java.util.concurrent.Callable; -public class LazyStringArray extends LazyTextArray +final class LazyStringArray extends LazyTextArray { LazyStringArray( Callable producer ) { @@ -42,19 +42,19 @@ public boolean equals( Object other ) } @Override - boolean equals( Value other ) + public boolean equals( Value other ) { return other.equals( getOrLoad() ); } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return PrimitiveArrayValues.equals( x, getOrLoad() ); } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return Arrays.equals( getOrLoad(), x ); } @@ -66,11 +66,17 @@ public int compareTo( ValueGroup.VTextArray other ) } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { PrimitiveArrayWriting.writeTo( writer, getOrLoad() ); } + @Override + public Object asPublic() + { + return getOrLoad().clone(); + } + @Override public int length() { diff --git a/community/values/src/main/java/org/neo4j/values/LazyTextArray.java b/community/values/src/main/java/org/neo4j/values/LazyTextArray.java index 97b208a9b132..b6900620790c 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyTextArray.java +++ b/community/values/src/main/java/org/neo4j/values/LazyTextArray.java @@ -29,43 +29,43 @@ abstract class LazyTextArray extends LazyArray implements ValueGroup.VText } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return false; } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return false; } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return false; } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return false; } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return false; } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return false; } @Override - boolean equals( boolean[] x ) + public boolean equals( boolean[] x ) { return false; } diff --git a/community/values/src/main/java/org/neo4j/values/LazyValue.java b/community/values/src/main/java/org/neo4j/values/LazyValue.java index 9e5ed9a81a59..eb72e8a1573c 100644 --- a/community/values/src/main/java/org/neo4j/values/LazyValue.java +++ b/community/values/src/main/java/org/neo4j/values/LazyValue.java @@ -21,7 +21,7 @@ import java.util.concurrent.Callable; -abstract class LazyValue extends Value +abstract class LazyValue extends ValueImpl { private volatile Object value; diff --git a/community/values/src/main/java/org/neo4j/values/NoValue.java b/community/values/src/main/java/org/neo4j/values/NoValue.java index d353f9802b18..8a4f7749377c 100644 --- a/community/values/src/main/java/org/neo4j/values/NoValue.java +++ b/community/values/src/main/java/org/neo4j/values/NoValue.java @@ -19,7 +19,7 @@ */ package org.neo4j.values; -public class NoValue extends Value +final class NoValue extends ValueImpl { @SuppressWarnings( "WeakerAccess" ) public static NoValue NO_VALUE = new NoValue(); @@ -41,89 +41,95 @@ public int hashCode() } @Override - boolean equals( Value other ) + public boolean equals( Value other ) { return false; } @Override - boolean equals( byte[] x ) + public boolean equals( byte[] x ) { return false; } @Override - boolean equals( short[] x ) + public boolean equals( short[] x ) { return false; } @Override - boolean equals( int[] x ) + public boolean equals( int[] x ) { return false; } @Override - boolean equals( long[] x ) + public boolean equals( long[] x ) { return false; } @Override - boolean equals( float[] x ) + public boolean equals( float[] x ) { return false; } @Override - boolean equals( double[] x ) + public boolean equals( double[] x ) { return false; } @Override - boolean equals( boolean x ) + public boolean equals( boolean x ) { return false; } @Override - boolean equals( boolean[] x ) + public boolean equals( boolean[] x ) { return false; } @Override - boolean equals( char x ) + public boolean equals( char x ) { return false; } @Override - boolean equals( String x ) + public boolean equals( String x ) { return false; } @Override - boolean equals( char[] x ) + public boolean equals( char[] x ) { return false; } @Override - boolean equals( String[] x ) + public boolean equals( String[] x ) { return false; } @Override - void writeTo( ValueWriter writer ) + public void writeTo( ValueWriter writer ) { writer.writeNull(); } + @Override + public Object asPublic() + { + return null; + } + @Override public ValueGroup.Id valueGroupId() { diff --git a/community/values/src/main/java/org/neo4j/values/Value.java b/community/values/src/main/java/org/neo4j/values/Value.java index 973d646f1273..fecf66f69b56 100644 --- a/community/values/src/main/java/org/neo4j/values/Value.java +++ b/community/values/src/main/java/org/neo4j/values/Value.java @@ -19,43 +19,28 @@ */ package org.neo4j.values; -public abstract class Value implements ValueGroup.WithId +public interface Value extends ValueGroup.WithId { - @Override - public boolean equals( Object other ) - { - throw new UnsupportedOperationException( "You forgot to implement `equals()` in concrete Value class!" ); - } + boolean equals( Value other ); - @Override - public int hashCode() - { - throw new UnsupportedOperationException( "You forgot to implement `hashCode()` in concrete Value class!" ); - } + boolean equals( byte[] x ); + boolean equals( short[] x ); + boolean equals( int[] x ); + boolean equals( long[] x ); - Value() - { - // only subclass in this package - } + boolean equals( float[] x ); + boolean equals( double[] x ); - abstract boolean equals( Value other ); + boolean equals( boolean x ); + boolean equals( boolean[] x ); - abstract boolean equals( byte[] x ); - abstract boolean equals( short[] x ); - abstract boolean equals( int[] x ); - abstract boolean equals( long[] x ); + boolean equals( char x ); + boolean equals( String x ); - abstract boolean equals( float[] x ); - abstract boolean equals( double[] x ); + boolean equals( char[] x ); + boolean equals( String[] x ); - abstract boolean equals( boolean x ); - abstract boolean equals( boolean[] x ); + void writeTo( ValueWriter writer ); - abstract boolean equals( char x ); - abstract boolean equals( String x ); - - abstract boolean equals( char[] x ); - abstract boolean equals( String[] x ); - - abstract void writeTo( ValueWriter writer ); + Object asPublic(); } diff --git a/community/values/src/main/java/org/neo4j/values/ValueImpl.java b/community/values/src/main/java/org/neo4j/values/ValueImpl.java new file mode 100644 index 000000000000..2d6f97f9939c --- /dev/null +++ b/community/values/src/main/java/org/neo4j/values/ValueImpl.java @@ -0,0 +1,35 @@ +/* + * Copyright (c) 2002-2017 "Neo Technology," + * Network Engine for Objects in Lund AB [http://neotechnology.com] + * + * This file is part of Neo4j. + * + * Neo4j is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package org.neo4j.values; + +abstract class ValueImpl implements Value +{ + @Override + public boolean equals( Object other ) + { + throw new UnsupportedOperationException( "You forgot to implement `equals()` in concrete Value class!" ); + } + + @Override + public int hashCode() + { + throw new UnsupportedOperationException( "You forgot to implement `hashCode()` in concrete Value class!" ); + } +} diff --git a/community/values/src/main/java/org/neo4j/values/Values.java b/community/values/src/main/java/org/neo4j/values/Values.java index 96a9c10fde07..56677d92cc48 100644 --- a/community/values/src/main/java/org/neo4j/values/Values.java +++ b/community/values/src/main/java/org/neo4j/values/Values.java @@ -23,7 +23,7 @@ import java.util.concurrent.Callable; @SuppressWarnings( "WeakerAccess" ) -class Values +public class Values { private Values() { @@ -31,6 +31,11 @@ private Values() // DIRECT FACTORY METHODS + public static Value noValue() + { + return NoValue.NO_VALUE; + } + public static Value stringValue( String value ) { return new DirectString( value ); @@ -156,54 +161,54 @@ public static Value floatValue( float value ) return new DirectFloat( value ); } - public static Value stringArrayValue( String[] value ) + public static Value stringArray( String[] value ) { return new DirectStringArray( value ); } - public static Value byteArrayValue( byte[] value ) + public static Value byteArray( byte[] value ) { return new DirectByteArray( value ); } - public static Value longArrayValue( long[] value ) + public static Value longArray( long[] value ) { return new DirectLongArray( value ); } - public static Value intArrayValue( int[] value ) + public static Value intArray( int[] value ) { return new DirectIntArray( value ); } - public static Value doubleArrayValue( double[] value ) + public static Value doubleArray( double[] value ) { return new DirectDoubleArray( value ); } - public static Value floatArrayValue( float[] value ) + public static Value floatArray( float[] value ) { return new DirectFloatArray( value ); } - public static Value booleanArrayValue( boolean[] value ) + public static Value booleanArray( boolean[] value ) { return new DirectBooleanArray( value ); } - public static Value charArrayValue( char[] value ) + public static Value charArray( char[] value ) { return new DirectCharArray( value ); } - public static Value shortArrayValue( short[] value ) + public static Value shortArray( short[] value ) { return new DirectShortArray( value ); } // BOXED FACTORY METHODS - static Value of( Object value ) + public static Value of( Object value ) { if ( value instanceof String ) { @@ -247,35 +252,35 @@ static Value of( Object value ) } if ( value instanceof byte[] ) { - return byteArrayValue( ((byte[]) value).clone() ); + return byteArray( ((byte[]) value).clone() ); } if ( value instanceof long[] ) { - return longArrayValue( ((long[]) value).clone() ); + return longArray( ((long[]) value).clone() ); } if ( value instanceof int[] ) { - return intArrayValue( ((int[]) value).clone() ); + return intArray( ((int[]) value).clone() ); } if ( value instanceof double[] ) { - return doubleArrayValue( ((double[]) value).clone() ); + return doubleArray( ((double[]) value).clone() ); } if ( value instanceof float[] ) { - return floatArrayValue( ((float[]) value).clone() ); + return floatArray( ((float[]) value).clone() ); } if ( value instanceof boolean[] ) { - return booleanArrayValue( ((boolean[]) value).clone() ); + return booleanArray( ((boolean[]) value).clone() ); } if ( value instanceof char[] ) { - return charArrayValue( ((char[]) value).clone() ); + return charArray( ((char[]) value).clone() ); } if ( value instanceof short[] ) { - return shortArrayValue( ((short[]) value).clone() ); + return shortArray( ((short[]) value).clone() ); } if ( value == null ) { @@ -290,39 +295,39 @@ private static Value arrayValue( Object[] value ) { if ( value instanceof String[] ) { - return stringArrayValue( copy( value, new String[value.length] ) ); + return stringArray( copy( value, new String[value.length] ) ); } if ( value instanceof Byte[] ) { - return byteArrayValue( copy( value, new byte[value.length] ) ); + return byteArray( copy( value, new byte[value.length] ) ); } if ( value instanceof Long[] ) { - return longArrayValue( copy( value, new long[value.length] ) ); + return longArray( copy( value, new long[value.length] ) ); } if ( value instanceof Integer[] ) { - return intArrayValue( copy( value, new int[value.length] ) ); + return intArray( copy( value, new int[value.length] ) ); } if ( value instanceof Double[] ) { - return doubleArrayValue( copy( value, new double[value.length] ) ); + return doubleArray( copy( value, new double[value.length] ) ); } if ( value instanceof Float[] ) { - return floatArrayValue( copy( value, new float[value.length] ) ); + return floatArray( copy( value, new float[value.length] ) ); } if ( value instanceof Boolean[] ) { - return booleanArrayValue( copy( value, new boolean[value.length] ) ); + return booleanArray( copy( value, new boolean[value.length] ) ); } if ( value instanceof Character[] ) { - return charArrayValue( copy( value, new char[value.length] ) ); + return charArray( copy( value, new char[value.length] ) ); } if ( value instanceof Short[] ) { - return shortArrayValue( copy( value, new short[value.length] ) ); + return shortArray( copy( value, new short[value.length] ) ); } throw new IllegalArgumentException( String.format( "%s[] is not a supported property value type", @@ -341,15 +346,4 @@ private static T copy( Object[] value, T target ) } return target; } - - enum SemanticType - { - NO_VALUE, - BOOLEAN, - NUMBER, - STRING, - BOOLEAN_ARR, - NUMBER_ARR, - STRING_ARR - } } diff --git a/community/values/src/test/java/org/neo4j/values/ValueAsPublicTest.java b/community/values/src/test/java/org/neo4j/values/ValueAsPublicTest.java new file mode 100644 index 000000000000..783a59538d68 --- /dev/null +++ b/community/values/src/test/java/org/neo4j/values/ValueAsPublicTest.java @@ -0,0 +1,350 @@ +package org.neo4j.values; + +import org.junit.Test; + +import java.util.Arrays; + +import static org.hamcrest.MatcherAssert.assertThat; +import static org.hamcrest.Matchers.equalTo; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +public class ValueAsPublicTest +{ + + Iterable scalars = Arrays.asList( + shouldGivePublic( Values.byteValue( (byte)1 ), (byte)1 ), + shouldGivePublic( Values.shortValue( (short)2 ), (short)2 ), + shouldGivePublic( Values.intValue( 3 ), 3 ), + shouldGivePublic( Values.longValue( 4L ), 4L ), + shouldGivePublic( Values.floatValue( 5.0f ), 5.0f ), + shouldGivePublic( Values.doubleValue( 6.0 ), 6.0 ), + shouldGivePublic( Values.booleanValue( false ), false ), + shouldGivePublic( Values.charValue( 'a' ), 'a' ), + shouldGivePublic( Values.stringValue( "b" ), "b" ), + shouldGivePublic( Values.lazyStringValue( () -> "c" ), "c" ) + ); + + @Test + public void shouldProvideScalarValueAsPublic() + { + for ( AsPublicTest test : scalars ) + { + test.assertGeneratesPublic(); + } + } + + // DIRECT ARRAYS + + @Test + public void shouldProvideDirectByteArrayAsPublic() + { + byte[] inStore = {1}; + Value value = Values.byteArray( inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return byte[]", asPublic instanceof byte[] ); + + byte[] arr = (byte[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (byte[])value.asPublic() ) ); + } + + @Test + public void shouldProvideDirectShortArrayAsPublic() + { + short[] inStore = {1}; + Value value = Values.shortArray( inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return short[]", asPublic instanceof short[] ); + + short[] arr = (short[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (short[])value.asPublic() ) ); + } + + @Test + public void shouldProvideDirectIntArrayAsPublic() + { + int[] inStore = {1}; + Value value = Values.intArray( inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return int[]", asPublic instanceof int[] ); + + int[] arr = (int[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (int[])value.asPublic() ) ); + } + + @Test + public void shouldProvideDirectLongArrayAsPublic() + { + long[] inStore = {1}; + Value value = Values.longArray( inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return long[]", asPublic instanceof long[] ); + + long[] arr = (long[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (long[])value.asPublic() ) ); + } + + @Test + public void shouldProvideDirectFloatArrayAsPublic() + { + float[] inStore = {1}; + Value value = Values.floatArray( inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return float[]", asPublic instanceof float[] ); + + float[] arr = (float[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (float[])value.asPublic() ) ); + } + + @Test + public void shouldProvideDirectDoubleArrayAsPublic() + { + double[] inStore = {1}; + Value value = Values.doubleArray( inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return double[]", asPublic instanceof double[] ); + + double[] arr = (double[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (double[])value.asPublic() ) ); + } + + @Test + public void shouldProvideDirectCharArrayAsPublic() + { + char[] inStore = {'a'}; + Value value = Values.charArray( inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return char[]", asPublic instanceof char[] ); + + char[] arr = (char[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = 'b'; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (char[])value.asPublic() ) ); + } + + @Test + public void shouldProvideDirectStringArrayAsPublic() + { + String[] inStore = {"a"}; + Value value = Values.stringArray( inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return String[]", asPublic instanceof String[] ); + + String[] arr = (String[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = "b"; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (String[])value.asPublic() ) ); + } + + @Test + public void shouldProvideDirectBooleanArrayAsPublic() + { + boolean[] inStore = {true}; + Value value = Values.booleanArray( inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return boolean[]", asPublic instanceof boolean[] ); + + boolean[] arr = (boolean[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = false; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (boolean[])value.asPublic() ) ); + } + + // LAZY ARRAYS + + @Test + public void shouldProvideLazyByteArrayAsPublic() + { + byte[] inStore = {1}; + Value value = Values.lazyByteArray( () -> inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return byte[]", asPublic instanceof byte[] ); + + byte[] arr = (byte[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (byte[])value.asPublic() ) ); + } + + @Test + public void shouldProvideLazyShortArrayAsPublic() + { + short[] inStore = {1}; + Value value = Values.lazyShortArray( () -> inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return short[]", asPublic instanceof short[] ); + + short[] arr = (short[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (short[])value.asPublic() ) ); + } + + @Test + public void shouldProvideLazyIntArrayAsPublic() + { + int[] inStore = {1}; + Value value = Values.lazyIntArray( () -> inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return int[]", asPublic instanceof int[] ); + + int[] arr = (int[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (int[])value.asPublic() ) ); + } + + @Test + public void shouldProvideLazyLongArrayAsPublic() + { + long[] inStore = {1}; + Value value = Values.lazyLongArray( () -> inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return long[]", asPublic instanceof long[] ); + + long[] arr = (long[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (long[])value.asPublic() ) ); + } + + @Test + public void shouldProvideLazyFloatArrayAsPublic() + { + float[] inStore = {1}; + Value value = Values.lazyFloatArray( () -> inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return float[]", asPublic instanceof float[] ); + + float[] arr = (float[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (float[])value.asPublic() ) ); + } + + @Test + public void shouldProvideLazyDoubleArrayAsPublic() + { + double[] inStore = {1}; + Value value = Values.lazyDoubleArray( () -> inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return double[]", asPublic instanceof double[] ); + + double[] arr = (double[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = -1; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (double[])value.asPublic() ) ); + } + + @Test + public void shouldProvideLazyCharArrayAsPublic() + { + char[] inStore = {'a'}; + Value value = Values.lazyCharArray( () -> inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return char[]", asPublic instanceof char[] ); + + char[] arr = (char[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = 'b'; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (char[])value.asPublic() ) ); + } + + @Test + public void shouldProvideLazyStringArrayAsPublic() + { + String[] inStore = {"a"}; + Value value = Values.lazyStringArray( () -> inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return String[]", asPublic instanceof String[] ); + + String[] arr = (String[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = "b"; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (String[])value.asPublic() ) ); + } + + @Test + public void shouldProvideLazyBooleanArrayAsPublic() + { + boolean[] inStore = {true}; + Value value = Values.lazyBooleanArray( () -> inStore ); + Object asPublic = value.asPublic(); + assertTrue( "should return boolean[]", asPublic instanceof boolean[] ); + + boolean[] arr = (boolean[]) asPublic; + assertTrue( "should have same values", Arrays.equals( inStore, arr ) ); + + arr[0] = false; + assertFalse( "should not modify inStore array", Arrays.equals( inStore, arr ) ); + assertTrue( "should still generate inStore array", Arrays.equals( inStore, (boolean[])value.asPublic() ) ); + } + + private AsPublicTest shouldGivePublic( Value value, Object asPublic ) + { + return new AsPublicTest( value, asPublic ); + } + + private class AsPublicTest + { + private final Value value; + private final Object expected; + + private AsPublicTest( Value value, Object expected ) + { + this.value = value; + this.expected = expected; + } + + void assertGeneratesPublic() + { + assertThat( value.asPublic(), equalTo( expected ) ); + } + } +} diff --git a/community/values/src/test/java/org/neo4j/values/ValueEqualityTest.java b/community/values/src/test/java/org/neo4j/values/ValueEqualityTest.java index 0db3848a45aa..51f1e3ec2c02 100644 --- a/community/values/src/test/java/org/neo4j/values/ValueEqualityTest.java +++ b/community/values/src/test/java/org/neo4j/values/ValueEqualityTest.java @@ -233,32 +233,32 @@ public static Test shouldNotMatch( char propertyValue, Object value ) public static Test shouldMatch( int[] propertyValue, Object value ) { - return new Test( Values.intArrayValue( propertyValue ), value, true ); + return new Test( Values.intArray( propertyValue ), value, true ); } public static Test shouldNotMatch( int[] propertyValue, Object value ) { - return new Test( Values.intArrayValue( propertyValue ), value, false ); + return new Test( Values.intArray( propertyValue ), value, false ); } public static Test shouldMatch( char[] propertyValue, Object value ) { - return new Test( Values.charArrayValue( propertyValue ), value, true ); + return new Test( Values.charArray( propertyValue ), value, true ); } public static Test shouldNotMatch( char[] propertyValue, Object value ) { - return new Test( Values.charArrayValue( propertyValue ), value, false ); + return new Test( Values.charArray( propertyValue ), value, false ); } public static Test shouldMatch( String[] propertyValue, Object value ) { - return new Test( Values.stringArrayValue( propertyValue ), value, true ); + return new Test( Values.stringArray( propertyValue ), value, true ); } public static Test shouldNotMatch( String[] propertyValue, Object value ) { - return new Test( Values.stringArrayValue( propertyValue ), value, false ); + return new Test( Values.stringArray( propertyValue ), value, false ); } private static class Test diff --git a/community/values/src/test/java/org/neo4j/values/ValuesTest.java b/community/values/src/test/java/org/neo4j/values/ValuesTest.java index 86bd0307a7d5..7c0f6e7f7a4e 100644 --- a/community/values/src/test/java/org/neo4j/values/ValuesTest.java +++ b/community/values/src/test/java/org/neo4j/values/ValuesTest.java @@ -22,17 +22,17 @@ import org.junit.Test; import static org.junit.Assert.assertTrue; -import static org.neo4j.values.Values.booleanArrayValue; +import static org.neo4j.values.Values.booleanArray; import static org.neo4j.values.Values.booleanValue; -import static org.neo4j.values.Values.byteArrayValue; +import static org.neo4j.values.Values.byteArray; import static org.neo4j.values.Values.byteValue; -import static org.neo4j.values.Values.charArrayValue; +import static org.neo4j.values.Values.charArray; import static org.neo4j.values.Values.charValue; -import static org.neo4j.values.Values.doubleArrayValue; +import static org.neo4j.values.Values.doubleArray; import static org.neo4j.values.Values.doubleValue; -import static org.neo4j.values.Values.floatArrayValue; +import static org.neo4j.values.Values.floatArray; import static org.neo4j.values.Values.floatValue; -import static org.neo4j.values.Values.intArrayValue; +import static org.neo4j.values.Values.intArray; import static org.neo4j.values.Values.intValue; import static org.neo4j.values.Values.lazyBooleanArray; import static org.neo4j.values.Values.lazyByteArray; @@ -44,11 +44,11 @@ import static org.neo4j.values.Values.lazyShortArray; import static org.neo4j.values.Values.lazyStringArray; import static org.neo4j.values.Values.lazyStringValue; -import static org.neo4j.values.Values.longArrayValue; +import static org.neo4j.values.Values.longArray; import static org.neo4j.values.Values.longValue; -import static org.neo4j.values.Values.shortArrayValue; +import static org.neo4j.values.Values.shortArray; import static org.neo4j.values.Values.shortValue; -import static org.neo4j.values.Values.stringArrayValue; +import static org.neo4j.values.Values.stringArray; import static org.neo4j.values.Values.stringValue; public class ValuesTest @@ -75,25 +75,25 @@ public void shouldBeEqualToItself() assertEqual( charValue( 'x' ), charValue( 'x' ) ); assertEqual( stringValue( "hi" ), stringValue( "hi" ) ); - assertEqual( booleanArrayValue( new boolean[]{} ), booleanArrayValue( new boolean[]{} ) ); - assertEqual( byteArrayValue( new byte[]{} ), byteArrayValue( new byte[]{} ) ); - assertEqual( shortArrayValue( new short[]{} ), shortArrayValue( new short[]{} ) ); - assertEqual( intArrayValue( new int[]{} ), intArrayValue( new int[]{} ) ); - assertEqual( longArrayValue( new long[]{} ), longArrayValue( new long[]{} ) ); - assertEqual( floatArrayValue( new float[]{} ), floatArrayValue( new float[]{} ) ); - assertEqual( doubleArrayValue( new double[]{} ), doubleArrayValue( new double[]{} ) ); - assertEqual( charArrayValue( new char[]{} ), charArrayValue( new char[]{} ) ); - assertEqual( stringArrayValue( new String[]{} ), stringArrayValue( new String[]{} ) ); + assertEqual( booleanArray( new boolean[]{} ), booleanArray( new boolean[]{} ) ); + assertEqual( byteArray( new byte[]{} ), byteArray( new byte[]{} ) ); + assertEqual( shortArray( new short[]{} ), shortArray( new short[]{} ) ); + assertEqual( intArray( new int[]{} ), intArray( new int[]{} ) ); + assertEqual( longArray( new long[]{} ), longArray( new long[]{} ) ); + assertEqual( floatArray( new float[]{} ), floatArray( new float[]{} ) ); + assertEqual( doubleArray( new double[]{} ), doubleArray( new double[]{} ) ); + assertEqual( charArray( new char[]{} ), charArray( new char[]{} ) ); + assertEqual( stringArray( new String[]{} ), stringArray( new String[]{} ) ); - assertEqual( booleanArrayValue( new boolean[]{true} ), booleanArrayValue( new boolean[]{true} ) ); - assertEqual( byteArrayValue( new byte[]{1} ), byteArrayValue( new byte[]{1} ) ); - assertEqual( shortArrayValue( new short[]{1} ), shortArrayValue( new short[]{1} ) ); - assertEqual( intArrayValue( new int[]{1} ), intArrayValue( new int[]{1} ) ); - assertEqual( longArrayValue( new long[]{1} ), longArrayValue( new long[]{1} ) ); - assertEqual( floatArrayValue( new float[]{1.0f} ), floatArrayValue( new float[]{1.0f} ) ); - assertEqual( doubleArrayValue( new double[]{1.0} ), doubleArrayValue( new double[]{1.0} ) ); - assertEqual( charArrayValue( new char[]{'x'} ), charArrayValue( new char[]{'x'} ) ); - assertEqual( stringArrayValue( new String[]{"hi"} ), stringArrayValue( new String[]{"hi"} ) ); + assertEqual( booleanArray( new boolean[]{true} ), booleanArray( new boolean[]{true} ) ); + assertEqual( byteArray( new byte[]{1} ), byteArray( new byte[]{1} ) ); + assertEqual( shortArray( new short[]{1} ), shortArray( new short[]{1} ) ); + assertEqual( intArray( new int[]{1} ), intArray( new int[]{1} ) ); + assertEqual( longArray( new long[]{1} ), longArray( new long[]{1} ) ); + assertEqual( floatArray( new float[]{1.0f} ), floatArray( new float[]{1.0f} ) ); + assertEqual( doubleArray( new double[]{1.0} ), doubleArray( new double[]{1.0} ) ); + assertEqual( charArray( new char[]{'x'} ), charArray( new char[]{'x'} ) ); + assertEqual( stringArray( new String[]{"hi"} ), stringArray( new String[]{"hi"} ) ); assertEqual( lazyStringValue( () -> "hi" ), lazyStringValue( () -> "hi" ) ); assertEqual( lazyBooleanArray( () -> new boolean[]{true} ), lazyBooleanArray( () -> new boolean[]{true} ) ); @@ -107,15 +107,15 @@ public void shouldBeEqualToItself() assertEqual( lazyStringArray( () -> new String[]{"hi"} ), lazyStringArray( () -> new String[]{"hi"} ) ); assertEqual( stringValue( "hi" ), lazyStringValue( () -> "hi" ) ); - assertEqual( booleanArrayValue( new boolean[]{true} ), lazyBooleanArray( () -> new boolean[]{true} ) ); - assertEqual( byteArrayValue( new byte[]{1} ), lazyByteArray( () -> new byte[]{1} ) ); - assertEqual( shortArrayValue( new short[]{1} ), lazyShortArray( () -> new short[]{1} ) ); - assertEqual( intArrayValue( new int[]{1} ), lazyIntArray( () -> new int[]{1} ) ); - assertEqual( longArrayValue( new long[]{1} ), lazyLongArray( () -> new long[]{1} ) ); - assertEqual( floatArrayValue( new float[]{1.0f} ), lazyFloatArray( () -> new float[]{1.0f} ) ); - assertEqual( doubleArrayValue( new double[]{1.0} ), lazyDoubleArray( () -> new double[]{1.0} ) ); - assertEqual( charArrayValue( new char[]{'a'} ), lazyCharArray( () -> new char[]{'a'} ) ); - assertEqual( stringArrayValue( new String[]{"hi"} ), lazyStringArray( () -> new String[]{"hi"} ) ); + assertEqual( booleanArray( new boolean[]{true} ), lazyBooleanArray( () -> new boolean[]{true} ) ); + assertEqual( byteArray( new byte[]{1} ), lazyByteArray( () -> new byte[]{1} ) ); + assertEqual( shortArray( new short[]{1} ), lazyShortArray( () -> new short[]{1} ) ); + assertEqual( intArray( new int[]{1} ), lazyIntArray( () -> new int[]{1} ) ); + assertEqual( longArray( new long[]{1} ), lazyLongArray( () -> new long[]{1} ) ); + assertEqual( floatArray( new float[]{1.0f} ), lazyFloatArray( () -> new float[]{1.0f} ) ); + assertEqual( doubleArray( new double[]{1.0} ), lazyDoubleArray( () -> new double[]{1.0} ) ); + assertEqual( charArray( new char[]{'a'} ), lazyCharArray( () -> new char[]{'a'} ) ); + assertEqual( stringArray( new String[]{"hi"} ), lazyStringArray( () -> new String[]{"hi"} ) ); } private void assertEqual( Value a, Value b )