private static boolean containsNull( MapValue map ) { boolean[] hasNull = {false}; map.foreach( ( s, value ) -> { if ( value == NO_VALUE ) { hasNull[0] = true; } } ); return hasNull[0]; }
@Override public int size() { int[] size = {0}; HashSet<String> seen = new HashSet<>(); ThrowingBiConsumer<String,AnyValue,RuntimeException> consume = ( key, value ) -> { if ( seen.add( key ) ) { size[0]++; } }; for ( int i = maps.length - 1; i >= 0; i-- ) { maps[i].foreach( consume ); } return size[0]; } }
@Override public <E extends Exception> void foreach( ThrowingBiConsumer<String,AnyValue,E> f ) throws E { map.foreach( f ); for ( int i = 0; i < updatedKeys.length; i++ ) { f.accept( updatedKeys[i], updatedValues[i] ); } }
@Override public <E extends Exception> void foreach( ThrowingBiConsumer<String,AnyValue,E> f ) throws E { map.foreach( ( s, anyValue ) -> f.accept( s, mapFunction.apply( s, anyValue ) ) ); }
@Override public int computeHash() { int[] h = new int[1]; foreach( ( key, value ) -> h[0] += key.hashCode() ^ value.hashCode() ); return h[0]; }
@Override public AnyValue mapMap( MapValue value ) { value.foreach( ( k, v ) -> v.map( this ) ); return value; }
@Override public Object mapMap( MapValue value ) { Map<Object,Object> map = new HashMap<>(); value.foreach( ( k, v ) -> map.put( k, v.map( this ) ) ); return map; }
@Override public <E extends Exception> void foreach( ThrowingBiConsumer<String,AnyValue,E> f ) throws E { map.foreach( ( s, anyValue ) -> { if ( filter.apply( s, anyValue ) ) { f.accept( s, anyValue ); } } ); }
@Override public String toString() { StringBuilder sb = new StringBuilder( getTypeName() + "{" ); final String[] sep = new String[]{""}; foreach( ( key, value ) -> { sb.append( sep[0] ); sb.append( key ); sb.append( " -> " ); sb.append( value ); sep[0] = ", "; } ); sb.append( '}' ); return sb.toString(); }
@Override public <E extends Exception> void foreach( ThrowingBiConsumer<String,AnyValue,E> f ) throws E { HashSet<String> seen = new HashSet<>(); ThrowingBiConsumer<String,AnyValue,E> consume = ( key, value ) -> { if ( seen.add( key ) ) { f.accept( key, value ); } }; for ( int i = maps.length - 1; i >= 0; i-- ) { maps[i].foreach( consume ); } }
public static PointValue fromMap( MapValue map ) { PointBuilder fields = new PointBuilder(); map.foreach( ( key, value ) -> fields.assign( key.toLowerCase(), value ) ); return fromInputFields( fields ); }
static <T> T build( final StructureBuilder<AnyValue,T> builder, MapValue map ) { if ( map.size() == 0 ) { throw new InvalidValuesArgumentException( "At least one temporal unit must be specified." ); } map.foreach( builder::add ); return builder.build(); }
public static Map<String,Object> readMetaDataMap( Neo4jPack.Unpacker unpacker ) throws IOException { MapValue metaDataMapValue = unpacker.unpackMap(); PrimitiveOnlyValueWriter writer = new PrimitiveOnlyValueWriter(); Map<String,Object> metaDataMap = new HashMap<>( metaDataMapValue.size() ); metaDataMapValue.foreach( ( key, value ) -> { Object convertedValue = AuthToken.containsSensitiveInformation( key ) ? writer.sensitiveValueAsObject( value, key ) : writer.valueAsObject( value ); metaDataMap.put( key, convertedValue ); } ); return metaDataMap; } }
@Override public AnyValue mapMap( MapValue value ) { MapValueBuilder builder = new MapValueBuilder(); value.foreach( ( k, v ) -> builder.add( k, v.map( this ) ) ); return builder.build(); }
static Map<String,Object> parseTransactionMetadata( MapValue meta ) throws BoltIOException { AnyValue anyValue = meta.get( TX_META_DATA_KEY ); if ( anyValue == Values.NO_VALUE ) { return null; } else if ( anyValue instanceof MapValue ) { MapValue mapValue = (MapValue) anyValue; TransactionMetadataWriter writer = new TransactionMetadataWriter(); Map<String,Object> txMeta = new HashMap<>( mapValue.size() ); mapValue.foreach( ( key, value ) -> txMeta.put( key, writer.valueAsObject( value ) ) ); return txMeta; } else { throw new BoltIOException( Status.Request.Invalid, "Expecting transaction metadata value to be a Map value, but got: " + anyValue ); } }
@Override public <E extends Exception> void writeTo( AnyValueWriter<E> writer ) throws E { writer.beginMap( size() ); foreach( ( s, anyValue ) -> { writer.writeString( s ); anyValue.writeTo( writer ); } ); writer.endMap(); }
private void assertMapValueEquals( MapValue a, MapValue b ) { assertThat( a, equalTo( b ) ); assertThat( a.size(), equalTo( b.size() ) ); assertThat( a.hashCode(), equalTo( b.hashCode() ) ); assertThat( a.keySet(), containsInAnyOrder( Iterables.asArray( String.class, b.keySet() ) ) ); assertThat( Arrays.asList( a.keys().asArray() ), containsInAnyOrder( b.keys().asArray() ) ); a.foreach( ( k, v ) -> assertThat( b.get( k ), equalTo( v ) ) ); b.foreach( ( k, v ) -> assertThat( a.get( k ), equalTo( v ) ) ); }
private static Map<String,Object> toRawMap( MapValue mapValue ) { Deserializer deserializer = new Deserializer(); HashMap<String,Object> map = new HashMap<>( mapValue.size() ); mapValue.foreach( ( key, value ) -> { value.writeTo( deserializer ); map.put( key, deserializer.value() ); } ); return map; }
private static void assertMapEqualsWithDelta( MapValue a, MapValue b, double delta ) { assertThat( "Map should have same size", a.size(), equalTo( b.size() ) ); a.foreach( ( key, value ) -> { //assertThat( "Missing key", b.get( key ) != Values.NO_VALUE ); AnyValue aValue = value; AnyValue bValue = b.get( key ); if ( aValue instanceof MapValue ) { assertThat( "Value mismatch", bValue instanceof MapValue ); assertMapEqualsWithDelta( (MapValue) aValue, (MapValue) bValue, delta ); } else if ( aValue instanceof DoubleValue ) { assertThat( "Value mismatch", ((DoubleValue) aValue).doubleValue(), closeTo( ((DoubleValue) bValue).doubleValue(), delta ) ); } else { assertThat( "Value mismatch", aValue, equalTo( bValue ) ); } } ); }
@Test public void shouldBeAbleToPackAndUnpackMap() throws IOException { // Given PackedOutputArray output = new PackedOutputArray(); Neo4jPack.Packer packer = neo4jPack.newPacker( output ); packer.packMapHeader( ALICE.properties().size() ); ALICE.properties().foreach( ( s, value ) -> { try { packer.pack( s ); packer.pack( value ); } catch ( IOException e ) { throw new UncheckedIOException( e ); } } ); AnyValue unpacked = unpacked( output.bytes() ); // Then assertThat( unpacked, instanceOf( MapValue.class ) ); MapValue unpackedMap = (MapValue) unpacked; assertThat( unpackedMap, equalTo( ALICE.properties() ) ); }