Datasets:
jitx
/
Methods2Test_java_unit_test_code

Dataset card Data Studio Files Community
target
stringlengths
20
113k
src_fm
stringlengths
11
86.3k
src_fm_fc
stringlengths
21
86.4k
src_fm_fc_co
stringlengths
30
86.4k
src_fm_fc_ms
stringlengths
42
86.8k
src_fm_fc_ms_ff
stringlengths
43
86.8k
@Test public void T_setString_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.STRING , "target" , allocator , parent , 4 ); memoryAllocator.setString( 0 , "a" ); memoryAllocator.setString( 1 , "b" ); memoryAllocator.setString( 5 , "c" ); memoryAllocator.setString( 1000 , "a b c" ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readText().toString() , "a" ); reader.setPosition( 1 ); assertEquals( reader.readText().toString() , "b" ); reader.setPosition( 5 ); assertEquals( reader.readText().toString() , "c" ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readText() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readText().toString() , "a b c" ); }
@Override public void setString( final int index , final String value ) throws IOException{ byte[] strBytes = value.getBytes( "UTF-8" ); setBytes( index , strBytes ); }
ArrowStringMemoryAllocator implements IMemoryAllocator { @Override public void setString( final int index , final String value ) throws IOException{ byte[] strBytes = value.getBytes( "UTF-8" ); setBytes( index , strBytes ); } }
ArrowStringMemoryAllocator implements IMemoryAllocator { @Override public void setString( final int index , final String value ) throws IOException{ byte[] strBytes = value.getBytes( "UTF-8" ); setBytes( index , strBytes ); } ArrowStringMemoryAllocator( final VarCharVector vector , final int rowCount ); }
ArrowStringMemoryAllocator implements IMemoryAllocator { @Override public void setString( final int index , final String value ) throws IOException{ byte[] strBytes = value.getBytes( "UTF-8" ); setBytes( index , strBytes ); } ArrowStringMemoryAllocator( final VarCharVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
ArrowStringMemoryAllocator implements IMemoryAllocator { @Override public void setString( final int index , final String value ) throws IOException{ byte[] strBytes = value.getBytes( "UTF-8" ); setBytes( index , strBytes ); } ArrowStringMemoryAllocator( final VarCharVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setShort_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.SHORT , "target" , allocator , parent , 1001 ); memoryAllocator.setShort( 0 , (short)100 ); memoryAllocator.setShort( 1 , (short)200 ); memoryAllocator.setShort( 5 , (short)255 ); memoryAllocator.setShort( 1000 , (short)10 ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( (short)( reader.readShort() ) , (short)100 ); reader.setPosition( 1 ); assertEquals( (short)( reader.readShort() ) , (short)200 ); reader.setPosition( 5 ); assertEquals( (short)( reader.readShort() ) , (short)255 ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readShort() , null ); } reader.setPosition( 1000 ); assertEquals( (short)( reader.readShort() ) , (short)10 ); }
@Override public void setShort( final int index , final short value ) throws IOException{ vector.setSafe( index , value ); }
ArrowShortMemoryAllocator implements IMemoryAllocator { @Override public void setShort( final int index , final short value ) throws IOException{ vector.setSafe( index , value ); } }
ArrowShortMemoryAllocator implements IMemoryAllocator { @Override public void setShort( final int index , final short value ) throws IOException{ vector.setSafe( index , value ); } ArrowShortMemoryAllocator( final SmallIntVector vector , final int rowCount ); }
ArrowShortMemoryAllocator implements IMemoryAllocator { @Override public void setShort( final int index , final short value ) throws IOException{ vector.setSafe( index , value ); } ArrowShortMemoryAllocator( final SmallIntVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
ArrowShortMemoryAllocator implements IMemoryAllocator { @Override public void setShort( final int index , final short value ) throws IOException{ vector.setSafe( index , value ); } ArrowShortMemoryAllocator( final SmallIntVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setLong_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.LONG , "target" , allocator , parent , 1001 ); memoryAllocator.setLong( 0 , (long)100 ); memoryAllocator.setLong( 1 , (long)200 ); memoryAllocator.setLong( 5 , (long)255 ); memoryAllocator.setLong( 1000 , (long)10 ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readLong().longValue() , (long)100 ); reader.setPosition( 1 ); assertEquals( reader.readLong().longValue() , (long)200 ); reader.setPosition( 5 ); assertEquals( reader.readLong().longValue() , (long)255 ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readLong() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readLong().longValue() , (long)10 ); }
@Override public void setLong( final int index , final long value ) throws IOException{ vector.setSafe( index , value ); }
ArrowLongMemoryAllocator implements IMemoryAllocator { @Override public void setLong( final int index , final long value ) throws IOException{ vector.setSafe( index , value ); } }
ArrowLongMemoryAllocator implements IMemoryAllocator { @Override public void setLong( final int index , final long value ) throws IOException{ vector.setSafe( index , value ); } ArrowLongMemoryAllocator( final BigIntVector vector , final int rowCount ); }
ArrowLongMemoryAllocator implements IMemoryAllocator { @Override public void setLong( final int index , final long value ) throws IOException{ vector.setSafe( index , value ); } ArrowLongMemoryAllocator( final BigIntVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
ArrowLongMemoryAllocator implements IMemoryAllocator { @Override public void setLong( final int index , final long value ) throws IOException{ vector.setSafe( index , value ); } ArrowLongMemoryAllocator( final BigIntVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setBoolean_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.BOOLEAN , "target" , allocator , parent , 4 ); memoryAllocator.setBoolean( 0 , true ); memoryAllocator.setBoolean( 1 , false ); memoryAllocator.setBoolean( 5 , true ); memoryAllocator.setBoolean( 1000 , true ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readBoolean().booleanValue() , true ); reader.setPosition( 1 ); assertEquals( reader.readBoolean().booleanValue() , false ); reader.setPosition( 5 ); assertEquals( reader.readBoolean().booleanValue() , true ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readBoolean() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readBoolean().booleanValue() , true ); }
@Override public void setBoolean( final int index , final boolean value ) throws IOException{ if( value ){ vector.setSafe( index , 1 ); } else{ vector.setSafe( index , 0 ); } }
ArrowBooleanMemoryAllocator implements IMemoryAllocator { @Override public void setBoolean( final int index , final boolean value ) throws IOException{ if( value ){ vector.setSafe( index , 1 ); } else{ vector.setSafe( index , 0 ); } } }
ArrowBooleanMemoryAllocator implements IMemoryAllocator { @Override public void setBoolean( final int index , final boolean value ) throws IOException{ if( value ){ vector.setSafe( index , 1 ); } else{ vector.setSafe( index , 0 ); } } ArrowBooleanMemoryAllocator( final BitVector vector , final int rowCount ); }
ArrowBooleanMemoryAllocator implements IMemoryAllocator { @Override public void setBoolean( final int index , final boolean value ) throws IOException{ if( value ){ vector.setSafe( index , 1 ); } else{ vector.setSafe( index , 0 ); } } ArrowBooleanMemoryAllocator( final BitVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
ArrowBooleanMemoryAllocator implements IMemoryAllocator { @Override public void setBoolean( final int index , final boolean value ) throws IOException{ if( value ){ vector.setSafe( index , 1 ); } else{ vector.setSafe( index , 0 ); } } ArrowBooleanMemoryAllocator( final BitVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setByte_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.BYTE , "target" , allocator , parent , 1001 ); memoryAllocator.setByte( 0 , (byte)100 ); memoryAllocator.setByte( 1 , (byte)200 ); memoryAllocator.setByte( 5 , (byte)255 ); memoryAllocator.setByte( 1000 , (byte)10 ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readByte().byteValue() , (byte)100 ); reader.setPosition( 1 ); assertEquals( reader.readByte().byteValue() , (byte)200 ); reader.setPosition( 5 ); assertEquals( reader.readByte().byteValue() , (byte)255 ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readByte() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readByte().byteValue() , (byte)10 ); }
@Override public void setByte( final int index , final byte value ) throws IOException{ vector.setSafe( index , value ); }
ArrowByteMemoryAllocator implements IMemoryAllocator { @Override public void setByte( final int index , final byte value ) throws IOException{ vector.setSafe( index , value ); } }
ArrowByteMemoryAllocator implements IMemoryAllocator { @Override public void setByte( final int index , final byte value ) throws IOException{ vector.setSafe( index , value ); } ArrowByteMemoryAllocator( final TinyIntVector vector , final int rowCount ); }
ArrowByteMemoryAllocator implements IMemoryAllocator { @Override public void setByte( final int index , final byte value ) throws IOException{ vector.setSafe( index , value ); } ArrowByteMemoryAllocator( final TinyIntVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
ArrowByteMemoryAllocator implements IMemoryAllocator { @Override public void setByte( final int index , final byte value ) throws IOException{ vector.setSafe( index , value ); } ArrowByteMemoryAllocator( final TinyIntVector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_setDouble_1() throws IOException{ BufferAllocator allocator = new RootAllocator( 1024 * 1024 * 10 ); SchemaChangeCallBack callBack = new SchemaChangeCallBack(); StructVector parent = new StructVector("root", allocator, new FieldType(false, Struct.INSTANCE, null, null), callBack); parent.allocateNew(); IMemoryAllocator memoryAllocator = ArrowMemoryAllocatorFactory.getFromStructVector( ColumnType.DOUBLE , "target" , allocator , parent , 4 ); memoryAllocator.setDouble( 0 , (double)0.1 ); memoryAllocator.setDouble( 1 , (double)0.2 ); memoryAllocator.setDouble( 5 , (double)0.255 ); memoryAllocator.setDouble( 1000 , (double)0.1 ); StructReader rootReader = parent.getReader(); FieldReader reader = rootReader.reader( "target" ); reader.setPosition( 0 ); assertEquals( reader.readDouble().doubleValue() , (double)0,1 ); reader.setPosition( 1 ); assertEquals( reader.readDouble().doubleValue() , (double)0.2 ); reader.setPosition( 5 ); assertEquals( reader.readDouble().doubleValue() , (double)0.255 ); for( int i = 6 ; i < 1000 ; i++ ){ reader.setPosition( i ); assertEquals( reader.readDouble() , null ); } reader.setPosition( 1000 ); assertEquals( reader.readDouble().doubleValue() , (double)0.1 ); }
@Override public void setDouble( final int index , final double value ) throws IOException{ vector.setSafe( index , value ); }
ArrowDoubleMemoryAllocator implements IMemoryAllocator { @Override public void setDouble( final int index , final double value ) throws IOException{ vector.setSafe( index , value ); } }
ArrowDoubleMemoryAllocator implements IMemoryAllocator { @Override public void setDouble( final int index , final double value ) throws IOException{ vector.setSafe( index , value ); } ArrowDoubleMemoryAllocator( final Float8Vector vector , final int rowCount ); }
ArrowDoubleMemoryAllocator implements IMemoryAllocator { @Override public void setDouble( final int index , final double value ) throws IOException{ vector.setSafe( index , value ); } ArrowDoubleMemoryAllocator( final Float8Vector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
ArrowDoubleMemoryAllocator implements IMemoryAllocator { @Override public void setDouble( final int index , final double value ) throws IOException{ vector.setSafe( index , value ); } ArrowDoubleMemoryAllocator( final Float8Vector vector , final int rowCount ); @Override void setNull( final int index ); @Override void setBoolean( final int index , final boolean value ); @Override void setByte( final int index , final byte value ); @Override void setShort( final int index , final short value ); @Override void setInteger( final int index , final int value ); @Override void setLong( final int index , final long value ); @Override void setFloat( final int index , final float value ); @Override void setDouble( final int index , final double value ); @Override void setBytes( final int index , final byte[] value ); @Override void setBytes( final int index , final byte[] value , final int start , final int length ); @Override void setString( final int index , final String value ); @Override void setString( final int index , final char[] value ); @Override void setString( final int index , final char[] value , final int start , final int length ); @Override void setPrimitiveObject( final int index , final PrimitiveObject value ); @Override void setArrayIndex( final int index , final int start , final int length ); @Override void setValueCount( final int count ); @Override int getValueCount(); @Override IMemoryAllocator getChild( final String columnName , final ColumnType type ); }
@Test public void T_getBlockIndexType_1(){ IBlockIndex bIndex = new FloatRangeBlockIndex(); assertEquals( BlockIndexType.RANGE_FLOAT , bIndex.getBlockIndexType() ); }
@Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_FLOAT; }
FloatRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_FLOAT; } }
FloatRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_FLOAT; } FloatRangeBlockIndex(); FloatRangeBlockIndex( final Float min , final Float max ); }
FloatRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_FLOAT; } FloatRangeBlockIndex(); FloatRangeBlockIndex( final Float min , final Float max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); Float getMin(); Float getMax(); }
FloatRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_FLOAT; } FloatRangeBlockIndex(); FloatRangeBlockIndex( final Float min , final Float max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); Float getMin(); Float getMax(); }
@Test public void T_getExpressionNode_1(){ HiveReaderSetting setting = new HiveReaderSetting( null , null , true , false , false ); assertEquals( null , setting.getExpressionNode() ); }
@Override public IExpressionNode getExpressionNode(){ return node; }
HiveReaderSetting implements IReaderSetting { @Override public IExpressionNode getExpressionNode(){ return node; } }
HiveReaderSetting implements IReaderSetting { @Override public IExpressionNode getExpressionNode(){ return node; } HiveReaderSetting( final Configuration config , final IExpressionNode node , final boolean isVectorModeFlag , final boolean disableSkipBlock , final boolean disableFilterPushdown ); HiveReaderSetting( final FileSplit split, final JobConf job ); }
HiveReaderSetting implements IReaderSetting { @Override public IExpressionNode getExpressionNode(){ return node; } HiveReaderSetting( final Configuration config , final IExpressionNode node , final boolean isVectorModeFlag , final boolean disableSkipBlock , final boolean disableFilterPushdown ); HiveReaderSetting( final FileSplit split, final JobConf job ); String createReadColumnNames( final String readColumnNames ); IExpressionNode createExpressionNode( final List<ExprNodeGenericFuncDesc> filterExprs ); Set<String> createPathSet( final Path target ); @Override boolean isVectorMode(); @Override boolean isDisableSkipBlock(); @Override boolean isDisableFilterPushdown(); @Override Configuration getReaderConfig(); @Override IExpressionNode getExpressionNode(); }
HiveReaderSetting implements IReaderSetting { @Override public IExpressionNode getExpressionNode(){ return node; } HiveReaderSetting( final Configuration config , final IExpressionNode node , final boolean isVectorModeFlag , final boolean disableSkipBlock , final boolean disableFilterPushdown ); HiveReaderSetting( final FileSplit split, final JobConf job ); String createReadColumnNames( final String readColumnNames ); IExpressionNode createExpressionNode( final List<ExprNodeGenericFuncDesc> filterExprs ); Set<String> createPathSet( final Path target ); @Override boolean isVectorMode(); @Override boolean isDisableSkipBlock(); @Override boolean isDisableFilterPushdown(); @Override Configuration getReaderConfig(); @Override IExpressionNode getExpressionNode(); }
@Test public void T_getBinarySize_1(){ FloatRangeBlockIndex bIndex = new FloatRangeBlockIndex( (float)10 , (float)20 ); assertEquals( Float.BYTES * 2 , bIndex.getBinarySize() ); }
@Override public int getBinarySize(){ return Float.BYTES * 2; }
FloatRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return Float.BYTES * 2; } }
FloatRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return Float.BYTES * 2; } FloatRangeBlockIndex(); FloatRangeBlockIndex( final Float min , final Float max ); }
FloatRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return Float.BYTES * 2; } FloatRangeBlockIndex(); FloatRangeBlockIndex( final Float min , final Float max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); Float getMin(); Float getMax(); }
FloatRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return Float.BYTES * 2; } FloatRangeBlockIndex(); FloatRangeBlockIndex( final Float min , final Float max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); Float getMin(); Float getMax(); }
@Test public void T_getBinarySize_1() throws IOException{ BlockIndexNode b = new BlockIndexNode(); assertEquals( 8 , b.getBinarySize() ); }
public int getBinarySize() throws IOException{ if( isDisable ){ return 0; } int length = 0; length += Integer.BYTES; if( blockIndex != null ){ length += Integer.BYTES; length += RangeBlockIndexNameShortCut.getShortCutName( blockIndex.getClass().getName() ).getBytes( "UTF-8" ).length; length += Integer.BYTES; length += blockIndex.getBinarySize(); } length += Integer.BYTES; for( Map.Entry<String,BlockIndexNode> entry : childContainer.entrySet() ){ int childLength = entry.getValue().getBinarySize(); if( childLength != 0 ){ length += Integer.BYTES; length += Integer.BYTES; length += entry.getKey().getBytes( "UTF-8" ).length; length += Integer.BYTES; length += childLength; } } return length; }
BlockIndexNode { public int getBinarySize() throws IOException{ if( isDisable ){ return 0; } int length = 0; length += Integer.BYTES; if( blockIndex != null ){ length += Integer.BYTES; length += RangeBlockIndexNameShortCut.getShortCutName( blockIndex.getClass().getName() ).getBytes( "UTF-8" ).length; length += Integer.BYTES; length += blockIndex.getBinarySize(); } length += Integer.BYTES; for( Map.Entry<String,BlockIndexNode> entry : childContainer.entrySet() ){ int childLength = entry.getValue().getBinarySize(); if( childLength != 0 ){ length += Integer.BYTES; length += Integer.BYTES; length += entry.getKey().getBytes( "UTF-8" ).length; length += Integer.BYTES; length += childLength; } } return length; } }
BlockIndexNode { public int getBinarySize() throws IOException{ if( isDisable ){ return 0; } int length = 0; length += Integer.BYTES; if( blockIndex != null ){ length += Integer.BYTES; length += RangeBlockIndexNameShortCut.getShortCutName( blockIndex.getClass().getName() ).getBytes( "UTF-8" ).length; length += Integer.BYTES; length += blockIndex.getBinarySize(); } length += Integer.BYTES; for( Map.Entry<String,BlockIndexNode> entry : childContainer.entrySet() ){ int childLength = entry.getValue().getBinarySize(); if( childLength != 0 ){ length += Integer.BYTES; length += Integer.BYTES; length += entry.getKey().getBytes( "UTF-8" ).length; length += Integer.BYTES; length += childLength; } } return length; } BlockIndexNode(); }
BlockIndexNode { public int getBinarySize() throws IOException{ if( isDisable ){ return 0; } int length = 0; length += Integer.BYTES; if( blockIndex != null ){ length += Integer.BYTES; length += RangeBlockIndexNameShortCut.getShortCutName( blockIndex.getClass().getName() ).getBytes( "UTF-8" ).length; length += Integer.BYTES; length += blockIndex.getBinarySize(); } length += Integer.BYTES; for( Map.Entry<String,BlockIndexNode> entry : childContainer.entrySet() ){ int childLength = entry.getValue().getBinarySize(); if( childLength != 0 ){ length += Integer.BYTES; length += Integer.BYTES; length += entry.getKey().getBytes( "UTF-8" ).length; length += Integer.BYTES; length += childLength; } } return length; } BlockIndexNode(); void setBlockIndex( final IBlockIndex blockIndex ); void disable(); IBlockIndex getBlockIndex(); BlockIndexNode getChildNode( final String nodeName ); void putChildNode( final String nodeName , final BlockIndexNode node ); int getBinarySize(); int toBinary( final byte[] buffer , final int start ); void clear(); static BlockIndexNode createFromBinary( final byte[] buffer , final int start ); }
BlockIndexNode { public int getBinarySize() throws IOException{ if( isDisable ){ return 0; } int length = 0; length += Integer.BYTES; if( blockIndex != null ){ length += Integer.BYTES; length += RangeBlockIndexNameShortCut.getShortCutName( blockIndex.getClass().getName() ).getBytes( "UTF-8" ).length; length += Integer.BYTES; length += blockIndex.getBinarySize(); } length += Integer.BYTES; for( Map.Entry<String,BlockIndexNode> entry : childContainer.entrySet() ){ int childLength = entry.getValue().getBinarySize(); if( childLength != 0 ){ length += Integer.BYTES; length += Integer.BYTES; length += entry.getKey().getBytes( "UTF-8" ).length; length += Integer.BYTES; length += childLength; } } return length; } BlockIndexNode(); void setBlockIndex( final IBlockIndex blockIndex ); void disable(); IBlockIndex getBlockIndex(); BlockIndexNode getChildNode( final String nodeName ); void putChildNode( final String nodeName , final BlockIndexNode node ); int getBinarySize(); int toBinary( final byte[] buffer , final int start ); void clear(); static BlockIndexNode createFromBinary( final byte[] buffer , final int start ); }
@Test public void T_getBlockIndexType_1(){ IBlockIndex bIndex = new StringRangeBlockIndex(); assertEquals( BlockIndexType.RANGE_STRING , bIndex.getBlockIndexType() ); }
@Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_STRING; }
StringRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_STRING; } }
StringRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_STRING; } StringRangeBlockIndex(); StringRangeBlockIndex( final String min , final String max ); }
StringRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_STRING; } StringRangeBlockIndex(); StringRangeBlockIndex( final String min , final String max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); String getMin(); String getMax(); }
StringRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_STRING; } StringRangeBlockIndex(); StringRangeBlockIndex( final String min , final String max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); String getMin(); String getMax(); }
@Test public void T_getBinarySize_1(){ StringRangeBlockIndex bIndex = new StringRangeBlockIndex( "10" , "20" ); assertEquals( Integer.BYTES * 2 + Character.BYTES * 4 , bIndex.getBinarySize() ); }
@Override public int getBinarySize(){ return ( min.length() * 2 ) + ( max.length() * 2 ) + 4 + 4; }
StringRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return ( min.length() * 2 ) + ( max.length() * 2 ) + 4 + 4; } }
StringRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return ( min.length() * 2 ) + ( max.length() * 2 ) + 4 + 4; } StringRangeBlockIndex(); StringRangeBlockIndex( final String min , final String max ); }
StringRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return ( min.length() * 2 ) + ( max.length() * 2 ) + 4 + 4; } StringRangeBlockIndex(); StringRangeBlockIndex( final String min , final String max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); String getMin(); String getMax(); }
StringRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return ( min.length() * 2 ) + ( max.length() * 2 ) + 4 + 4; } StringRangeBlockIndex(); StringRangeBlockIndex( final String min , final String max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); String getMin(); String getMax(); }
@Test public void T_getBlockIndexType_1(){ IBlockIndex bIndex = new ByteRangeBlockIndex(); assertEquals( BlockIndexType.RANGE_BYTE , bIndex.getBlockIndexType() ); }
@Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_BYTE; }
ByteRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_BYTE; } }
ByteRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_BYTE; } ByteRangeBlockIndex(); ByteRangeBlockIndex( final byte min , final byte max ); }
ByteRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_BYTE; } ByteRangeBlockIndex(); ByteRangeBlockIndex( final byte min , final byte max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); byte getMin(); byte getMax(); }
ByteRangeBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.RANGE_BYTE; } ByteRangeBlockIndex(); ByteRangeBlockIndex( final byte min , final byte max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); byte getMin(); byte getMax(); }
@Test public void T_getBinarySize_1(){ ByteRangeBlockIndex bIndex = new ByteRangeBlockIndex( (byte)10 , (byte)20 ); assertEquals( 2 , bIndex.getBinarySize() ); }
@Override public int getBinarySize(){ return Byte.BYTES * 2; }
ByteRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return Byte.BYTES * 2; } }
ByteRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return Byte.BYTES * 2; } ByteRangeBlockIndex(); ByteRangeBlockIndex( final byte min , final byte max ); }
ByteRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return Byte.BYTES * 2; } ByteRangeBlockIndex(); ByteRangeBlockIndex( final byte min , final byte max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); byte getMin(); byte getMax(); }
ByteRangeBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return Byte.BYTES * 2; } ByteRangeBlockIndex(); ByteRangeBlockIndex( final byte min , final byte max ); @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); byte getMin(); byte getMax(); }
@Test public void T_getBlockIndexType_1(){ assertEquals( BlockIndexType.UNSUPPORTED , UnsupportedBlockIndex.INSTANCE.getBlockIndexType() ); }
@Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.UNSUPPORTED; }
UnsupportedBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.UNSUPPORTED; } }
UnsupportedBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.UNSUPPORTED; } }
UnsupportedBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.UNSUPPORTED; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); }
UnsupportedBlockIndex implements IBlockIndex { @Override public BlockIndexType getBlockIndexType(){ return BlockIndexType.UNSUPPORTED; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); static final IBlockIndex INSTANCE; }
@Test public void T_merge_1(){ assertFalse( UnsupportedBlockIndex.INSTANCE.merge( null ) ); }
@Override public boolean merge( final IBlockIndex blockIndex ){ return false; }
UnsupportedBlockIndex implements IBlockIndex { @Override public boolean merge( final IBlockIndex blockIndex ){ return false; } }
UnsupportedBlockIndex implements IBlockIndex { @Override public boolean merge( final IBlockIndex blockIndex ){ return false; } }
UnsupportedBlockIndex implements IBlockIndex { @Override public boolean merge( final IBlockIndex blockIndex ){ return false; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); }
UnsupportedBlockIndex implements IBlockIndex { @Override public boolean merge( final IBlockIndex blockIndex ){ return false; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); static final IBlockIndex INSTANCE; }
@Test public void T_getBinarySize_1(){ assertEquals( 0 , UnsupportedBlockIndex.INSTANCE.getBinarySize() ); }
@Override public int getBinarySize(){ return 0; }
UnsupportedBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return 0; } }
UnsupportedBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return 0; } }
UnsupportedBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return 0; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); }
UnsupportedBlockIndex implements IBlockIndex { @Override public int getBinarySize(){ return 0; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); static final IBlockIndex INSTANCE; }
@Test public void T_binary_1(){ byte[] binary = UnsupportedBlockIndex.INSTANCE.toBinary(); assertEquals( 0 , binary.length ); }
@Override public byte[] toBinary(){ return new byte[0]; }
UnsupportedBlockIndex implements IBlockIndex { @Override public byte[] toBinary(){ return new byte[0]; } }
UnsupportedBlockIndex implements IBlockIndex { @Override public byte[] toBinary(){ return new byte[0]; } }
UnsupportedBlockIndex implements IBlockIndex { @Override public byte[] toBinary(){ return new byte[0]; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); }
UnsupportedBlockIndex implements IBlockIndex { @Override public byte[] toBinary(){ return new byte[0]; } @Override BlockIndexType getBlockIndexType(); @Override boolean merge( final IBlockIndex blockIndex ); @Override int getBinarySize(); @Override byte[] toBinary(); @Override void setFromBinary( final byte[] buffer , final int start , final int length ); @Override List<Integer> getBlockSpreadIndex( final IFilter filter ); @Override IBlockIndex getNewInstance(); static final IBlockIndex INSTANCE; }
@Test public void T_write_1() throws IOException{ ParserWritable writable = new ParserWritable(); assertThrows( UnsupportedOperationException.class , () -> { writable.write( null ); } ); }
@Override public void write( final DataOutput dataOutput ) throws IOException { throw new UnsupportedOperationException("write unsupported"); }
ParserWritable implements Writable { @Override public void write( final DataOutput dataOutput ) throws IOException { throw new UnsupportedOperationException("write unsupported"); } }
ParserWritable implements Writable { @Override public void write( final DataOutput dataOutput ) throws IOException { throw new UnsupportedOperationException("write unsupported"); } }
ParserWritable implements Writable { @Override public void write( final DataOutput dataOutput ) throws IOException { throw new UnsupportedOperationException("write unsupported"); } void set( final IParser parser ); @Override void write( final DataOutput dataOutput ); @Override void readFields( final DataInput dataInput ); }
ParserWritable implements Writable { @Override public void write( final DataOutput dataOutput ) throws IOException { throw new UnsupportedOperationException("write unsupported"); } void set( final IParser parser ); @Override void write( final DataOutput dataOutput ); @Override void readFields( final DataInput dataInput ); public IParser parser; }
@Test public void testAll () throws Exception { synchronized (this.lock_) { Promise<List<Object>> p = Promise.all ( new Promise<> (settlement -> settlement.resolve (10)), new Promise<> (settlement -> settlement.resolve (20)) ); p.then (resolved (values -> { Assert.assertEquals (2, values.size ()); Assert.assertEquals (10, values.get (0)); Assert.assertEquals (20, values.get (1)); this.isComplete_ = true; synchronized (this.lock_) { this.lock_.notify (); } })); this.lock_.wait (5000); Assert.assertTrue (this.isComplete_); } }
public static Promise <List <Object>> all (Promise <?>... promises) { return all (Arrays.asList (promises)); }
Promise { public static Promise <List <Object>> all (Promise <?>... promises) { return all (Arrays.asList (promises)); } }
Promise { public static Promise <List <Object>> all (Promise <?>... promises) { return all (Arrays.asList (promises)); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); }
Promise { public static Promise <List <Object>> all (Promise <?>... promises) { return all (Arrays.asList (promises)); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); }
Promise { public static Promise <List <Object>> all (Promise <?>... promises) { return all (Arrays.asList (promises)); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); static final OnRejected ignoreReason; }
@Test public void testRace () throws Exception { synchronized (this.lock_) { Promise<Integer> p = Promise.race ( new Promise<> (settlement -> { { try { Thread.sleep (500); settlement.resolve (10); } catch (InterruptedException e) { settlement.reject (e); } } }), new Promise<> (settlement -> { { try { Thread.sleep (300); settlement.resolve (20); } catch (InterruptedException e) { settlement.reject (e); } } }), new Promise<> (settlement -> { { try { Thread.sleep (600); settlement.resolve (30); } catch (InterruptedException e) { settlement.reject (e); } } }) ); p.then (resolved (value -> { Assert.assertEquals (20, (int) value); Assert.assertFalse (isComplete_); isComplete_ = true; synchronized (lock_) { lock_.notify (); } })) ._catch (rejected (reason -> Assert.fail ())); this.lock_.wait (5000); Assert.assertTrue (this.isComplete_); } }
public static <U> Promise <U> race (Promise <U>... promises) { return race (Arrays.asList (promises)); }
Promise { public static <U> Promise <U> race (Promise <U>... promises) { return race (Arrays.asList (promises)); } }
Promise { public static <U> Promise <U> race (Promise <U>... promises) { return race (Arrays.asList (promises)); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); }
Promise { public static <U> Promise <U> race (Promise <U>... promises) { return race (Arrays.asList (promises)); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); }
Promise { public static <U> Promise <U> race (Promise <U>... promises) { return race (Arrays.asList (promises)); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); static final OnRejected ignoreReason; }
@Test public void testCancel () throws Exception { synchronized (this.lock_) { Promise<Integer> p1 = new Promise<> (settlement -> { try { Thread.sleep (300); } catch (InterruptedException e) { this.isComplete_ = true; } }); Thread.sleep (100); p1.cancel (true); p1.then (resolved (value -> this.isComplete_ = false)); this.lock_.wait (100); Assert.assertTrue (p1.isCancelled ()); Assert.assertTrue (this.isComplete_); } }
public boolean cancel () { return this.cancel (true); }
Promise { public boolean cancel () { return this.cancel (true); } }
Promise { public boolean cancel () { return this.cancel (true); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); }
Promise { public boolean cancel () { return this.cancel (true); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); }
Promise { public boolean cancel () { return this.cancel (true); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); static final OnRejected ignoreReason; }
@Test public void testAwaitResolved () throws Throwable { int result = await (this.makeSimplePromise (5, 2000)); Assert.assertEquals (result, 5); }
public static <T> T await (Promise <T> promise) throws Throwable { return await (promise, true); }
Promise { public static <T> T await (Promise <T> promise) throws Throwable { return await (promise, true); } }
Promise { public static <T> T await (Promise <T> promise) throws Throwable { return await (promise, true); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); }
Promise { public static <T> T await (Promise <T> promise) throws Throwable { return await (promise, true); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); }
Promise { public static <T> T await (Promise <T> promise) throws Throwable { return await (promise, true); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); static final OnRejected ignoreReason; }
@Test public void testAwaitRejected () { try { await (this.makeSimplePromise (new IllegalStateException ("REJECTED"), 2000)); Assert.fail ("The promise should have been rejected"); } catch (Throwable e) { Assert.assertEquals ("REJECTED", e.getMessage ()); } }
public static <T> T await (Promise <T> promise) throws Throwable { return await (promise, true); }
Promise { public static <T> T await (Promise <T> promise) throws Throwable { return await (promise, true); } }
Promise { public static <T> T await (Promise <T> promise) throws Throwable { return await (promise, true); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); }
Promise { public static <T> T await (Promise <T> promise) throws Throwable { return await (promise, true); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); }
Promise { public static <T> T await (Promise <T> promise) throws Throwable { return await (promise, true); } Promise(PromiseExecutor<T> impl); Promise(String name, PromiseExecutor<T> impl); private Promise(T value); private Promise(Throwable reason); private Promise(String name, PromiseExecutor<T> impl, Status status, T value, Throwable reason); static OnResolved <T, U> resolved(ResolveNoReturn <T> resolveNoReturn); static OnRejected rejected(RejectNoReturn rejectNoReturn); static T await(Promise <T> promise); static T await(Promise <T> promise, boolean interruptible); static T await(Promise <T> promise, Date deadline); static T await(Promise <T> promise, long nanos); static T await(Promise <T> promise, long time, TimeUnit unit); String getName(); Status getStatus(); boolean isCancelled(); boolean isPending(); boolean isResolved(); boolean isRejected(); boolean cancel(); boolean cancel(boolean mayInterruptIfRunning); Promise <U> then(OnResolved <T, U> onResolved); Promise <U> then(OnResolvedExecutor <T, U> onResolved); Promise <U> then(OnResolved <T, U> onResolved, OnRejected onRejected); Promise <U> _catch(OnRejected onRejected); Promise <U> _catch(OnRejectedExecutor onRejected); @SuppressWarnings ("unchecked") Promise <U> then(OnResolvedExecutor <T, U> onResolved, OnRejectedExecutor <U> onRejected); static Promise <T> resolve(T value); static Promise <T> value(T value); static Promise <T> reject(Throwable reason); static Promise <List <Object>> all(Promise <?>... promises); static Promise <List <Object>> all(final List <Promise <?>> promises); static Promise <U> race(Promise <U>... promises); static Promise <U> race(final List <Promise <U>> promises); static final OnRejected ignoreReason; }
@Test public final void testAddValueSUM1() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.SUM); statisticalOperation.addValue(1); statisticalOperation.addValue(2); statisticalOperation.addValue(3); statisticalOperation.addValue(4); statisticalOperation.addValue(5); statisticalOperation.addValue(6); statisticalOperation.addValue(7); statisticalOperation.addValue(8); statisticalOperation.addValue(9); assertEquals(55, statisticalOperation.addValue(10), 0.0); }
public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
@Test public void testClear() { addAllRectangles(); assertTrue(tree.getDrawingObjects().size() == 4); tree.clear(); assertTrue(tree.getDrawingObjects().isEmpty()); }
@Override public void clear() { if (threadSafe) { synchronized (lock) { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } } else { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void clear() { if (threadSafe) { synchronized (lock) { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } } else { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void clear() { if (threadSafe) { synchronized (lock) { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } } else { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void clear() { if (threadSafe) { synchronized (lock) { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } } else { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void clear() { if (threadSafe) { synchronized (lock) { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } } else { final Set<DrawingObject> dos = tree.searchItems(); for (final DrawingObject dob : dos) { dob.removeBoundingBoxChangeListener(this); } tree.clear(); insertionOrder.clear(); insertionOrderLargest = 0; insertionOrderSmallest = 0; } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testContains() { addAllRectangles(); assertTrue(tree.getDrawingObjects(rectangle1.getBoundingBox()).contains(rectangle1)); assertTrue(tree.getDrawingObjects(rectangle2.getBoundingBox()).contains(rectangle2)); assertTrue(tree.getDrawingObjects(rectangle3.getBoundingBox()).contains(rectangle3)); assertTrue(tree.getDrawingObjects(rectangle4.getBoundingBox()).contains(rectangle4)); }
@Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testGetDrawingObjects() { addAllRectangles(); final Set<DrawingObject> set = tree.getDrawingObjects(); assertTrue(set.size() == 4); assertTrue(set.contains(rectangle1)); assertTrue(set.contains(rectangle2)); assertTrue(set.contains(rectangle3)); assertTrue(set.contains(rectangle4)); }
@Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testgetDrawingObjectsRectangle() { addAllRectangles(); Set<DrawingObject> collisionEntities; collisionEntities = tree.getDrawingObjects(new AbsoluteRectangle(upperLeftX, upperLeftY, width, height)); assertTrue(collisionEntities.contains(rectangle1)); assertTrue(collisionEntities.contains(rectangle2)); assertTrue(collisionEntities.contains(rectangle3)); assertTrue(collisionEntities.contains(rectangle4)); collisionEntities = tree.getDrawingObjects(upperLeftQuadrant); assertTrue(collisionEntities.size() == 1); assertTrue(collisionEntities.contains(rectangle1)); collisionEntities = tree.getDrawingObjects(upperRightQuadrant); assertTrue(collisionEntities.size() == 1); assertTrue(collisionEntities.contains(rectangle2)); collisionEntities = tree.getDrawingObjects(lowerRightQuadrant); assertTrue(collisionEntities.size() == 1); assertTrue(collisionEntities.contains(rectangle3)); collisionEntities = tree.getDrawingObjects(lowerLeftQuadrant); assertTrue(collisionEntities.size() == 1); assertTrue(collisionEntities.contains(rectangle4)); }
@Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testPushBack() { Set<DrawingObject> set; addAllRectangles(); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[3] == rectangle4); assertTrue(set.toArray()[0] == rectangle1); tree.pushBack(rectangle1); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[0] == rectangle1); tree.pushBack(rectangle2); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[0] == rectangle2); tree.pushBack(rectangle3); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[0] == rectangle3); tree.pushBack(rectangle4); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[0] == rectangle4); }
@Override public void pushBack(final DrawingObject object) { if (threadSafe) { synchronized (lock) { insertionOrder.put(object, --insertionOrderSmallest); } } else { insertionOrder.put(object, --insertionOrderSmallest); } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void pushBack(final DrawingObject object) { if (threadSafe) { synchronized (lock) { insertionOrder.put(object, --insertionOrderSmallest); } } else { insertionOrder.put(object, --insertionOrderSmallest); } } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void pushBack(final DrawingObject object) { if (threadSafe) { synchronized (lock) { insertionOrder.put(object, --insertionOrderSmallest); } } else { insertionOrder.put(object, --insertionOrderSmallest); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void pushBack(final DrawingObject object) { if (threadSafe) { synchronized (lock) { insertionOrder.put(object, --insertionOrderSmallest); } } else { insertionOrder.put(object, --insertionOrderSmallest); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void pushBack(final DrawingObject object) { if (threadSafe) { synchronized (lock) { insertionOrder.put(object, --insertionOrderSmallest); } } else { insertionOrder.put(object, --insertionOrderSmallest); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testRemove() { addAllRectangles(); tree.remove(rectangle1); assertFalse(tree.getDrawingObjects().contains(rectangle1)); assertTrue(tree.getDrawingObjects().contains(rectangle2)); assertTrue(tree.getDrawingObjects().contains(rectangle3)); assertTrue(tree.getDrawingObjects().contains(rectangle4)); tree.remove(rectangle2); assertFalse(tree.getDrawingObjects().contains(rectangle1)); assertFalse(tree.getDrawingObjects().contains(rectangle2)); assertTrue(tree.getDrawingObjects().contains(rectangle3)); assertTrue(tree.getDrawingObjects().contains(rectangle4)); tree.remove(rectangle3); assertFalse(tree.getDrawingObjects().contains(rectangle1)); assertFalse(tree.getDrawingObjects().contains(rectangle2)); assertFalse(tree.getDrawingObjects().contains(rectangle3)); assertTrue(tree.getDrawingObjects().contains(rectangle4)); tree.remove(rectangle4); assertFalse(tree.getDrawingObjects().contains(rectangle1)); assertFalse(tree.getDrawingObjects().contains(rectangle2)); assertFalse(tree.getDrawingObjects().contains(rectangle3)); assertFalse(tree.getDrawingObjects().contains(rectangle4)); }
@Override public void remove(final DrawingObject d) { if (threadSafe) { final Rectangle rect = d.getBoundingBox().rectangle; synchronized (lock) { tree.removeItem(d, rect); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } } else { tree.removeItem(d, d.getBoundingBox().rectangle); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void remove(final DrawingObject d) { if (threadSafe) { final Rectangle rect = d.getBoundingBox().rectangle; synchronized (lock) { tree.removeItem(d, rect); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } } else { tree.removeItem(d, d.getBoundingBox().rectangle); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void remove(final DrawingObject d) { if (threadSafe) { final Rectangle rect = d.getBoundingBox().rectangle; synchronized (lock) { tree.removeItem(d, rect); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } } else { tree.removeItem(d, d.getBoundingBox().rectangle); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void remove(final DrawingObject d) { if (threadSafe) { final Rectangle rect = d.getBoundingBox().rectangle; synchronized (lock) { tree.removeItem(d, rect); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } } else { tree.removeItem(d, d.getBoundingBox().rectangle); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void remove(final DrawingObject d) { if (threadSafe) { final Rectangle rect = d.getBoundingBox().rectangle; synchronized (lock) { tree.removeItem(d, rect); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } } else { tree.removeItem(d, d.getBoundingBox().rectangle); d.removeBoundingBoxChangeListener(this); insertionOrder.remove(d); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testSearchPoint() { addAllRectangles(); Set<DrawingObject> search; final AbsolutePosition rect1pos = rectangle1.getPosition(); final AbsolutePosition rect2pos = rectangle2.getPosition(); final AbsolutePosition rect3pos = rectangle3.getPosition(); final AbsolutePosition rect4pos = rectangle4.getPosition(); search = tree.getDrawingObjects(new AbsoluteRectangle(rect1pos.x + rectangle1.getWidth() / 2, rect1pos.y + rectangle1.getHeight() / 2, 1, 1)); assertTrue(search.contains(rectangle1)); search = tree.getDrawingObjects(new AbsoluteRectangle(rect2pos.x + rectangle1.getWidth() / 2, rect2pos.y + rectangle1.getHeight() / 2, 1, 1)); assertTrue(search.contains(rectangle2)); search = tree.getDrawingObjects(new AbsoluteRectangle(rect3pos.x + rectangle1.getWidth() / 2, rect3pos.y + rectangle1.getHeight() / 2, 1, 1)); assertTrue(search.contains(rectangle3)); search = tree.getDrawingObjects(new AbsoluteRectangle(rect4pos.x + rectangle1.getWidth() / 2, rect4pos.y + rectangle1.getHeight() / 2, 1, 1)); assertTrue(search.contains(rectangle4)); search = tree.getDrawingObjects(new AbsoluteRectangle(upperLeftX + (width * 1 / 4), upperLeftY + (height * 1 / 4), 1, 1)); assertTrue(search.isEmpty()); search = tree.getDrawingObjects(new AbsoluteRectangle(upperLeftX + (width * 3 / 4), upperLeftY + (height * 1 / 4), 1, 1)); assertTrue(search.isEmpty()); search = tree.getDrawingObjects(new AbsoluteRectangle(upperLeftX + (width * 1 / 4), upperLeftY + (height * 3 / 4), 1, 1)); assertTrue(search.isEmpty()); search = tree.getDrawingObjects(new AbsoluteRectangle(upperLeftX + (width * 3 / 4), upperLeftY + (height * 3 / 4), 1, 1)); assertTrue(search.isEmpty()); }
@Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public Set<DrawingObject> getDrawingObjects() { return getDrawingObjects(false); } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void borderTest() { final Rectangle rectBorderLeft = new Rectangle(upperLeftX, upperLeftY + (height / 2), rectWidth, rectHeight); final Rectangle rectBorderTop = new Rectangle(upperLeftX + (width / 2), upperLeftY, rectWidth, rectHeight); final Rectangle rectBorderRight = new Rectangle(upperLeftX + width - rectWidth, upperLeftY + (height / 2), rectWidth, rectHeight); final Rectangle rectBorderBottom = new Rectangle(upperLeftX + (width / 2), upperLeftY + height - rectHeight, rectWidth, rectHeight); try { tree.add(rectBorderLeft); } catch (final RuntimeException e) { assertTrue(false); } try { tree.add(rectBorderTop); } catch (final RuntimeException e) { assertTrue(false); } try { tree.add(rectBorderRight); } catch (final RuntimeException e) { assertTrue(false); } try { tree.add(rectBorderBottom); } catch (final RuntimeException e) { assertTrue(false); } }
@Override public void add(final DrawingObject d) { if (threadSafe) { synchronized (lock) { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } else { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void add(final DrawingObject d) { if (threadSafe) { synchronized (lock) { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } else { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void add(final DrawingObject d) { if (threadSafe) { synchronized (lock) { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } else { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void add(final DrawingObject d) { if (threadSafe) { synchronized (lock) { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } else { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void add(final DrawingObject d) { if (threadSafe) { synchronized (lock) { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } else { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public final void testAddValueSUM2() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.SUM); statisticalOperation.addValue(1); statisticalOperation.addValue(2); statisticalOperation.addValue(3); statisticalOperation.addValue(4); statisticalOperation.addValue(5); statisticalOperation.addValue(6); statisticalOperation.addValue(7); statisticalOperation.addValue(8); statisticalOperation.addValue(9); statisticalOperation.addValue(10); assertEquals(66, statisticalOperation.addValue(11), 0.0); }
public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
@Test public final void testAddValueAVG() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.AVG); statisticalOperation.addValue(1); assertEquals(2, statisticalOperation.addValue(3), 0.0); }
public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
@Test public final void testAddValueMAX() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.MAX); statisticalOperation.addValue(1); assertEquals(3, statisticalOperation.addValue(3), 0.0); }
public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
@Test public final void testAddValueMIN() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.MIN); statisticalOperation.addValue(1); assertEquals(1, statisticalOperation.addValue(3), 0.0); }
public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
@Test public final void testAddValueMEDIAN1() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.MEDIAN); statisticalOperation.addValue(1); assertEquals(1, statisticalOperation.addValue(3), 0.0); }
public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
@Test public final void testAddValueMEDIAN2() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.MEDIAN); statisticalOperation.addValue(1); statisticalOperation.addValue(4); statisticalOperation.addValue(7); statisticalOperation.addValue(5); assertEquals(4, statisticalOperation.addValue(3), 0.0); }
public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
@Test public final void testAddValueMEDIAN3() { final StatisticalOperation statisticalOperation = new StatisticalOperation(10, STATISTICAL_OPERATIONS.MEDIAN); statisticalOperation.addValue(1); statisticalOperation.addValue(1); statisticalOperation.addValue(5); statisticalOperation.addValue(6); statisticalOperation.addValue(20); statisticalOperation.addValue(1000); statisticalOperation.addValue(5); statisticalOperation.addValue(1); statisticalOperation.addValue(9); statisticalOperation.addValue(2); statisticalOperation.addValue(7); statisticalOperation.addValue(8); statisticalOperation.addValue(1); statisticalOperation.addValue(4); statisticalOperation.addValue(7); assertEquals(5, statisticalOperation.addValue(6), 0.0); }
public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
StatisticalOperation { public synchronized float addValue(final float value) { sumBuffer += value; if ((minBuffer == null) || (value < minBuffer)) { minBuffer = value; } if ((maxBuffer == null) || (value > maxBuffer)) { maxBuffer = value; } buffer[pointer++] = value; pointer = pointer % bufferSize; if (maxValidFieldValue < buffer.length) { ++maxValidFieldValue; } return getValue(defaultOperation); } StatisticalOperation(final int bufferSize, final STATISTICAL_OPERATIONS defaultOperation); STATISTICAL_OPERATIONS getDefaultOperation(); void setDefaultOperation(final STATISTICAL_OPERATIONS defaultOperation); synchronized float addValue(final float value); synchronized final float getValue(); synchronized final Float getValue(final STATISTICAL_OPERATIONS operation); synchronized final float getValue(final float[] values); synchronized final float getValue(final STATISTICAL_OPERATIONS operation, final float[] values); synchronized void reset(); @Override synchronized StatisticalOperation clone(); }
@Test public void testAdd() { Set<DrawingObject> set; addAllRectangles(); set = tree.getDrawingObjects(upperLeftQuadrant); assertTrue(set.size() == 1); assertTrue(set.contains(rectangle1)); rectangle1.setPosition(upperRightQuadrant.getLowerLeft()); rectangle1.syncBoundingBoxForce(); set = tree.getDrawingObjects(upperLeftQuadrant); assertTrue(set.size() == 0); assertTrue(!set.contains(rectangle1)); set = tree.getDrawingObjects(upperRightQuadrant); assertTrue(set.size() == 2); assertTrue(set.contains(rectangle1)); assertTrue(set.contains(rectangle2)); rectangle1.setPosition(lowerRightQuadrant.getLowerLeft()); rectangle1.syncBoundingBoxForce(); set = tree.getDrawingObjects(upperRightQuadrant); assertTrue(set.size() == 1); assertTrue(set.contains(rectangle2)); set = tree.getDrawingObjects(lowerRightQuadrant); assertTrue(set.size() == 2); assertTrue(set.contains(rectangle1)); assertTrue(set.contains(rectangle3)); rectangle1.setPosition(lowerLeftQuadrant.getLowerLeft()); rectangle1.syncBoundingBoxForce(); set = tree.getDrawingObjects(lowerRightQuadrant); assertTrue(set.size() == 1); assertTrue(set.contains(rectangle3)); assertTrue(!set.contains(rectangle1)); set = tree.getDrawingObjects(lowerLeftQuadrant); assertTrue(set.size() == 2); assertTrue(set.contains(rectangle1)); assertTrue(set.contains(rectangle4)); }
@Override public void add(final DrawingObject d) { if (threadSafe) { synchronized (lock) { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } else { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void add(final DrawingObject d) { if (threadSafe) { synchronized (lock) { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } else { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void add(final DrawingObject d) { if (threadSafe) { synchronized (lock) { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } else { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void add(final DrawingObject d) { if (threadSafe) { synchronized (lock) { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } else { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void add(final DrawingObject d) { if (threadSafe) { synchronized (lock) { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } else { if (insertionOrder.containsKey(d)) { throw new RuntimeException("Don't do double insert, no no ;-)"); } d.addBoundingBoxChangedListener(this); insertionOrder.put(d, ++insertionOrderLargest); tree.insertItem(d, d.getBoundingBox().rectangle); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void testBringToFront() { Set<DrawingObject> set; addAllRectangles(); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[0] == rectangle1); assertTrue(set.toArray()[3] == rectangle4); tree.bringToFront(rectangle1); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[3] == rectangle1); tree.bringToFront(rectangle2); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[3] == rectangle2); tree.bringToFront(rectangle3); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[3] == rectangle3); tree.bringToFront(rectangle4); set = tree.getDrawingObjects(true); assertTrue(set.toArray()[3] == rectangle4); }
@Override public void bringToFront(final DrawingObject dob) { if (threadSafe) { synchronized (lock) { insertionOrder.put(dob, ++insertionOrderLargest); } } else { insertionOrder.put(dob, ++insertionOrderLargest); } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void bringToFront(final DrawingObject dob) { if (threadSafe) { synchronized (lock) { insertionOrder.put(dob, ++insertionOrderLargest); } } else { insertionOrder.put(dob, ++insertionOrderLargest); } } }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void bringToFront(final DrawingObject dob) { if (threadSafe) { synchronized (lock) { insertionOrder.put(dob, ++insertionOrderLargest); } } else { insertionOrder.put(dob, ++insertionOrderLargest); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void bringToFront(final DrawingObject dob) { if (threadSafe) { synchronized (lock) { insertionOrder.put(dob, ++insertionOrderLargest); } } else { insertionOrder.put(dob, ++insertionOrderLargest); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
QuadTree implements Layer, BoundingBoxChangeListener { @Override public void bringToFront(final DrawingObject dob) { if (threadSafe) { synchronized (lock) { insertionOrder.put(dob, ++insertionOrderLargest); } } else { insertionOrder.put(dob, ++insertionOrderLargest); } } @SuppressWarnings("synthetic-access") QuadTree(final int originX, final int originY, final int totalSideLength, final int minSideLength, final int capacity, final boolean threadSafe); @Override void add(final DrawingObject d); @Override void bringToFront(final DrawingObject dob); @Override void clear(); @Override Set<DrawingObject> getDrawingObjects(); @Override SortedSet<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect); @Override Set<DrawingObject> getDrawingObjects(final AbsoluteRectangle rect, final boolean sorted); @Override Set<DrawingObject> getDrawingObjects(final boolean sorted); @Override void onBoundingBoxChanged(final DrawingObject updatedDrawingObject, final AbsoluteRectangle oldBox); @Override void pushBack(final DrawingObject object); @Override void remove(final DrawingObject d); @Override void removeAll(final Collection<DrawingObject> dos); }
@Test public void addTest(){ JSONArray array = JSONUtil.createArray(); array.add("value1"); array.add("value2"); array.add("value3"); Assert.assertEquals(array.get(0), "value1"); }
@Override public boolean add(Object e) { return this.rawArrayList.add(JSONUtil.wrap(e)); }
JSONArray extends JSONGetter<Integer> implements JSON, List<Object> { @Override public boolean add(Object e) { return this.rawArrayList.add(JSONUtil.wrap(e)); } }
JSONArray extends JSONGetter<Integer> implements JSON, List<Object> { @Override public boolean add(Object e) { return this.rawArrayList.add(JSONUtil.wrap(e)); } JSONArray(); JSONArray(JSONTokener x); JSONArray(String source); JSONArray(Object arrayOrCollection); }
JSONArray extends JSONGetter<Integer> implements JSON, List<Object> { @Override public boolean add(Object e) { return this.rawArrayList.add(JSONUtil.wrap(e)); } JSONArray(); JSONArray(JSONTokener x); JSONArray(String source); JSONArray(Object arrayOrCollection); boolean isNull(int index); String join(String separator); @Override Object get(int index); @Override Object getObj(Integer index, Object defaultValue); @Override Object getByExp(String expression); JSONArray put(Object value); JSONArray put(int index, Object value); JSONObject toJSONObject(JSONArray names); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); @Override Iterator<Object> iterator(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Object e); @Override Object remove(int index); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends Object> c); @Override boolean addAll(int index, Collection<? extends Object> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Object set(int index, Object element); @Override void add(int index, Object element); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override ListIterator<Object> listIterator(); @Override ListIterator<Object> listIterator(int index); @Override List<Object> subList(int fromIndex, int toIndex); Object toArray(Class<?> clazz); Object[] toArray(Class<?> arrayClass, boolean ignoreError); }
JSONArray extends JSONGetter<Integer> implements JSON, List<Object> { @Override public boolean add(Object e) { return this.rawArrayList.add(JSONUtil.wrap(e)); } JSONArray(); JSONArray(JSONTokener x); JSONArray(String source); JSONArray(Object arrayOrCollection); boolean isNull(int index); String join(String separator); @Override Object get(int index); @Override Object getObj(Integer index, Object defaultValue); @Override Object getByExp(String expression); JSONArray put(Object value); JSONArray put(int index, Object value); JSONObject toJSONObject(JSONArray names); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); @Override Iterator<Object> iterator(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Object e); @Override Object remove(int index); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends Object> c); @Override boolean addAll(int index, Collection<? extends Object> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Object set(int index, Object element); @Override void add(int index, Object element); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override ListIterator<Object> listIterator(); @Override ListIterator<Object> listIterator(int index); @Override List<Object> subList(int fromIndex, int toIndex); Object toArray(Class<?> clazz); Object[] toArray(Class<?> arrayClass, boolean ignoreError); }
@Test public void parseTest(){ String jsonStr = "[\"value1\", \"value2\", \"value3\"]"; JSONArray array = JSONUtil.parseArray(jsonStr); Assert.assertEquals(array.get(0), "value1"); }
@Override public Object get(int index) { return this.rawArrayList.get(index); }
JSONArray extends JSONGetter<Integer> implements JSON, List<Object> { @Override public Object get(int index) { return this.rawArrayList.get(index); } }
JSONArray extends JSONGetter<Integer> implements JSON, List<Object> { @Override public Object get(int index) { return this.rawArrayList.get(index); } JSONArray(); JSONArray(JSONTokener x); JSONArray(String source); JSONArray(Object arrayOrCollection); }
JSONArray extends JSONGetter<Integer> implements JSON, List<Object> { @Override public Object get(int index) { return this.rawArrayList.get(index); } JSONArray(); JSONArray(JSONTokener x); JSONArray(String source); JSONArray(Object arrayOrCollection); boolean isNull(int index); String join(String separator); @Override Object get(int index); @Override Object getObj(Integer index, Object defaultValue); @Override Object getByExp(String expression); JSONArray put(Object value); JSONArray put(int index, Object value); JSONObject toJSONObject(JSONArray names); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); @Override Iterator<Object> iterator(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Object e); @Override Object remove(int index); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends Object> c); @Override boolean addAll(int index, Collection<? extends Object> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Object set(int index, Object element); @Override void add(int index, Object element); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override ListIterator<Object> listIterator(); @Override ListIterator<Object> listIterator(int index); @Override List<Object> subList(int fromIndex, int toIndex); Object toArray(Class<?> clazz); Object[] toArray(Class<?> arrayClass, boolean ignoreError); }
JSONArray extends JSONGetter<Integer> implements JSON, List<Object> { @Override public Object get(int index) { return this.rawArrayList.get(index); } JSONArray(); JSONArray(JSONTokener x); JSONArray(String source); JSONArray(Object arrayOrCollection); boolean isNull(int index); String join(String separator); @Override Object get(int index); @Override Object getObj(Integer index, Object defaultValue); @Override Object getByExp(String expression); JSONArray put(Object value); JSONArray put(int index, Object value); JSONObject toJSONObject(JSONArray names); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); @Override Iterator<Object> iterator(); @Override int size(); @Override boolean isEmpty(); @Override boolean contains(Object o); @Override Object[] toArray(); @Override T[] toArray(T[] a); @Override boolean add(Object e); @Override Object remove(int index); @Override boolean remove(Object o); @Override boolean containsAll(Collection<?> c); @Override boolean addAll(Collection<? extends Object> c); @Override boolean addAll(int index, Collection<? extends Object> c); @Override boolean removeAll(Collection<?> c); @Override boolean retainAll(Collection<?> c); @Override void clear(); @Override Object set(int index, Object element); @Override void add(int index, Object element); @Override int indexOf(Object o); @Override int lastIndexOf(Object o); @Override ListIterator<Object> listIterator(); @Override ListIterator<Object> listIterator(int index); @Override List<Object> subList(int fromIndex, int toIndex); Object toArray(Class<?> clazz); Object[] toArray(Class<?> arrayClass, boolean ignoreError); }
@Test public void putAllTest(){ JSONObject json1 = JSONUtil.createObj(); json1.put("a", "value1"); json1.put("b", "value2"); json1.put("c", "value3"); json1.put("d", true); JSONObject json2 = JSONUtil.createObj(); json2.put("a", "value21"); json2.put("b", "value22"); json1.putAll(json2); Assert.assertEquals(json1.get("a"), "value21"); Assert.assertEquals(json1.get("b"), "value22"); Assert.assertEquals(json1.get("c"), "value3"); }
@Override public void putAll(Map<? extends String, ? extends Object> m) { rawHashMap.putAll(m); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { @Override public void putAll(Map<? extends String, ? extends Object> m) { rawHashMap.putAll(m); } }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { @Override public void putAll(Map<? extends String, ? extends Object> m) { rawHashMap.putAll(m); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { @Override public void putAll(Map<? extends String, ? extends Object> m) { rawHashMap.putAll(m); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); boolean isNull(String key); JSONArray toJSONArray(Collection<String> names); T toBean(Class<T> clazz); T toBean(Class<T> clazz, boolean ignoreError); T toBean(T bean); T toBean(T bean, boolean ignoreError); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Object get(Object key); @Override Object getObj(String key, Object defaultValue); @Override Object getByExp(String expression); @Override JSONObject put(String key, Object value); JSONObject putOnce(String key, Object value); JSONObject putOpt(String key, Object value); @Override void putAll(Map<? extends String, ? extends Object> m); JSONObject accumulate(String key, Object value); JSONObject append(String key, Object value); JSONObject increment(String key); @Override Object remove(Object key); @Override void clear(); @Override Set<String> keySet(); @Override Collection<Object> values(); @Override Set<Entry<String, Object>> entrySet(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { @Override public void putAll(Map<? extends String, ? extends Object> m) { rawHashMap.putAll(m); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); boolean isNull(String key); JSONArray toJSONArray(Collection<String> names); T toBean(Class<T> clazz); T toBean(Class<T> clazz, boolean ignoreError); T toBean(T bean); T toBean(T bean, boolean ignoreError); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Object get(Object key); @Override Object getObj(String key, Object defaultValue); @Override Object getByExp(String expression); @Override JSONObject put(String key, Object value); JSONObject putOnce(String key, Object value); JSONObject putOpt(String key, Object value); @Override void putAll(Map<? extends String, ? extends Object> m); JSONObject accumulate(String key, Object value); JSONObject append(String key, Object value); JSONObject increment(String key); @Override Object remove(Object key); @Override void clear(); @Override Set<String> keySet(); @Override Collection<Object> values(); @Override Set<Entry<String, Object>> entrySet(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); }
@Test public void parseTest(){ String jsonStr = "{\"b\":\"value2\",\"c\":\"value3\",\"a\":\"value1\", \"d\": true}"; JSONObject jsonObject = JSONUtil.parseObj(jsonStr); Assert.assertEquals(jsonObject.get("a"), "value1"); Assert.assertEquals(jsonObject.get("b"), "value2"); Assert.assertEquals(jsonObject.get("c"), "value3"); Assert.assertEquals(jsonObject.get("d"), true); }
@Override public Object get(Object key) { return rawHashMap.get(key); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { @Override public Object get(Object key) { return rawHashMap.get(key); } }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { @Override public Object get(Object key) { return rawHashMap.get(key); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { @Override public Object get(Object key) { return rawHashMap.get(key); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); boolean isNull(String key); JSONArray toJSONArray(Collection<String> names); T toBean(Class<T> clazz); T toBean(Class<T> clazz, boolean ignoreError); T toBean(T bean); T toBean(T bean, boolean ignoreError); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Object get(Object key); @Override Object getObj(String key, Object defaultValue); @Override Object getByExp(String expression); @Override JSONObject put(String key, Object value); JSONObject putOnce(String key, Object value); JSONObject putOpt(String key, Object value); @Override void putAll(Map<? extends String, ? extends Object> m); JSONObject accumulate(String key, Object value); JSONObject append(String key, Object value); JSONObject increment(String key); @Override Object remove(Object key); @Override void clear(); @Override Set<String> keySet(); @Override Collection<Object> values(); @Override Set<Entry<String, Object>> entrySet(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { @Override public Object get(Object key) { return rawHashMap.get(key); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); boolean isNull(String key); JSONArray toJSONArray(Collection<String> names); T toBean(Class<T> clazz); T toBean(Class<T> clazz, boolean ignoreError); T toBean(T bean); T toBean(T bean, boolean ignoreError); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Object get(Object key); @Override Object getObj(String key, Object defaultValue); @Override Object getByExp(String expression); @Override JSONObject put(String key, Object value); JSONObject putOnce(String key, Object value); JSONObject putOpt(String key, Object value); @Override void putAll(Map<? extends String, ? extends Object> m); JSONObject accumulate(String key, Object value); JSONObject append(String key, Object value); JSONObject increment(String key); @Override Object remove(Object key); @Override void clear(); @Override Set<String> keySet(); @Override Collection<Object> values(); @Override Set<Entry<String, Object>> entrySet(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); }
@Test public void toBeanTest(){ JSONObject subJson = JSONUtil.createObj().put("value1", "strValue1").put("value2", "234"); JSONObject json = JSONUtil.createObj() .put("strValue", "strTest") .put("intValue", 123) .put("beanValue", subJson) .put("list", JSONUtil.createArray().put("a").put("b")); TestBean bean = json.toBean(TestBean.class); Console.log(bean); }
public <T> T toBean(Class<T> clazz) { return toBean(clazz, false); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { public <T> T toBean(Class<T> clazz) { return toBean(clazz, false); } }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { public <T> T toBean(Class<T> clazz) { return toBean(clazz, false); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { public <T> T toBean(Class<T> clazz) { return toBean(clazz, false); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); boolean isNull(String key); JSONArray toJSONArray(Collection<String> names); T toBean(Class<T> clazz); T toBean(Class<T> clazz, boolean ignoreError); T toBean(T bean); T toBean(T bean, boolean ignoreError); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Object get(Object key); @Override Object getObj(String key, Object defaultValue); @Override Object getByExp(String expression); @Override JSONObject put(String key, Object value); JSONObject putOnce(String key, Object value); JSONObject putOpt(String key, Object value); @Override void putAll(Map<? extends String, ? extends Object> m); JSONObject accumulate(String key, Object value); JSONObject append(String key, Object value); JSONObject increment(String key); @Override Object remove(Object key); @Override void clear(); @Override Set<String> keySet(); @Override Collection<Object> values(); @Override Set<Entry<String, Object>> entrySet(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { public <T> T toBean(Class<T> clazz) { return toBean(clazz, false); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); boolean isNull(String key); JSONArray toJSONArray(Collection<String> names); T toBean(Class<T> clazz); T toBean(Class<T> clazz, boolean ignoreError); T toBean(T bean); T toBean(T bean, boolean ignoreError); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Object get(Object key); @Override Object getObj(String key, Object defaultValue); @Override Object getByExp(String expression); @Override JSONObject put(String key, Object value); JSONObject putOnce(String key, Object value); JSONObject putOpt(String key, Object value); @Override void putAll(Map<? extends String, ? extends Object> m); JSONObject accumulate(String key, Object value); JSONObject append(String key, Object value); JSONObject increment(String key); @Override Object remove(Object key); @Override void clear(); @Override Set<String> keySet(); @Override Collection<Object> values(); @Override Set<Entry<String, Object>> entrySet(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); }
@Test public void beanTransTest(){ UserA userA = new UserA(); userA.setA("A user"); userA.setName("nameTest"); userA.setDate(new Date()); JSONObject userAJson = JSONUtil.parseObj(userA); UserB userB = JSONUtil.toBean(userAJson, UserB.class); Assert.assertEquals(userA.getName(), userB.getName()); Assert.assertEquals(userA.getDate(), userB.getDate()); }
public <T> T toBean(Class<T> clazz) { return toBean(clazz, false); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { public <T> T toBean(Class<T> clazz) { return toBean(clazz, false); } }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { public <T> T toBean(Class<T> clazz) { return toBean(clazz, false); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { public <T> T toBean(Class<T> clazz) { return toBean(clazz, false); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); boolean isNull(String key); JSONArray toJSONArray(Collection<String> names); T toBean(Class<T> clazz); T toBean(Class<T> clazz, boolean ignoreError); T toBean(T bean); T toBean(T bean, boolean ignoreError); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Object get(Object key); @Override Object getObj(String key, Object defaultValue); @Override Object getByExp(String expression); @Override JSONObject put(String key, Object value); JSONObject putOnce(String key, Object value); JSONObject putOpt(String key, Object value); @Override void putAll(Map<? extends String, ? extends Object> m); JSONObject accumulate(String key, Object value); JSONObject append(String key, Object value); JSONObject increment(String key); @Override Object remove(Object key); @Override void clear(); @Override Set<String> keySet(); @Override Collection<Object> values(); @Override Set<Entry<String, Object>> entrySet(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); }
JSONObject extends JSONGetter<String> implements JSON, Map<String, Object> { public <T> T toBean(Class<T> clazz) { return toBean(clazz, false); } JSONObject(); JSONObject(JSONObject jsonObject, String... names); JSONObject(JSONTokener x); JSONObject(Object source); JSONObject(Object pojo, String[] names); JSONObject(String source); boolean isNull(String key); JSONArray toJSONArray(Collection<String> names); T toBean(Class<T> clazz); T toBean(Class<T> clazz, boolean ignoreError); T toBean(T bean); T toBean(T bean, boolean ignoreError); @Override int size(); @Override boolean isEmpty(); @Override boolean containsKey(Object key); @Override boolean containsValue(Object value); @Override Object get(Object key); @Override Object getObj(String key, Object defaultValue); @Override Object getByExp(String expression); @Override JSONObject put(String key, Object value); JSONObject putOnce(String key, Object value); JSONObject putOpt(String key, Object value); @Override void putAll(Map<? extends String, ? extends Object> m); JSONObject accumulate(String key, Object value); JSONObject append(String key, Object value); JSONObject increment(String key); @Override Object remove(Object key); @Override void clear(); @Override Set<String> keySet(); @Override Collection<Object> values(); @Override Set<Entry<String, Object>> entrySet(); @Override int hashCode(); @Override boolean equals(Object obj); @Override String toString(); @Override String toJSONString(int indentFactor); @Override Writer write(Writer writer); @Override Writer write(Writer writer, int indentFactor, int indent); }
@Test public void testGetChange() { setUpPutChangeMocks(false); final CassandraLoader testInstance = CassandraLoader.instanceOf(this.cluster, "keyspace", RULE_SET_NAME); assertNotNull(testInstance); verify(this.cluster, times(1)).getConfiguration(); final Result<ChangeSet> loadedChangeSet = testInstance.getChange(CHANGE_NAME); assertNotNull(loadedChangeSet); if (!loadedChangeSet.isSuccess()) { assertTrue(loadedChangeSet.getException().getMessage(), loadedChangeSet.isSuccess()); } verifyRuleChanges(); }
public Result<ChangeSet> getChange(final String changeSetName) { try { final ResultSet resultSet = this.session.execute(CQL_GET_ACTIVE_CHANGE, changeSetName); EhSupport.ensure(!resultSet.isExhausted(), "ChangeSet %s does not exist in %s.", changeSetName, this.keyspace); UUID changeSetId = null; final Map<Change, List<Change>> changes = new HashMap<>(); for (final Row row : resultSet) { changeSetId = row.getUUID("id"); final UUID changeid = row.getUUID("changeid"); final String rulesetname = row.getString("rulesetname"); final Instant activationTime = row.get("activationtime", Instant.class); final DateRange changeRange = new DateRange(row.get("start", Instant.class), row.get("end", Instant.class)); final Change newchange = new Change(changeid, rulesetname, activationTime, changeRange, getAuditForChange(row), getRuleChangeForChange(row), getValueGroupChange(row)); final List<Change> internalChanges = changes.computeIfAbsent(newchange, value -> new ArrayList<>()); internalChanges.add(newchange); } return Result.success(new ChangeSet(changeSetId, changeSetName, mergeChangesIntoSet(changes))); } catch (final Exception exception) { return Result.failure(() -> exception); } }
CassandraLoader implements Loader<DecisionTreeRuleSet>, Persister, ComponentLifecycle { public Result<ChangeSet> getChange(final String changeSetName) { try { final ResultSet resultSet = this.session.execute(CQL_GET_ACTIVE_CHANGE, changeSetName); EhSupport.ensure(!resultSet.isExhausted(), "ChangeSet %s does not exist in %s.", changeSetName, this.keyspace); UUID changeSetId = null; final Map<Change, List<Change>> changes = new HashMap<>(); for (final Row row : resultSet) { changeSetId = row.getUUID("id"); final UUID changeid = row.getUUID("changeid"); final String rulesetname = row.getString("rulesetname"); final Instant activationTime = row.get("activationtime", Instant.class); final DateRange changeRange = new DateRange(row.get("start", Instant.class), row.get("end", Instant.class)); final Change newchange = new Change(changeid, rulesetname, activationTime, changeRange, getAuditForChange(row), getRuleChangeForChange(row), getValueGroupChange(row)); final List<Change> internalChanges = changes.computeIfAbsent(newchange, value -> new ArrayList<>()); internalChanges.add(newchange); } return Result.success(new ChangeSet(changeSetId, changeSetName, mergeChangesIntoSet(changes))); } catch (final Exception exception) { return Result.failure(() -> exception); } } }
CassandraLoader implements Loader<DecisionTreeRuleSet>, Persister, ComponentLifecycle { public Result<ChangeSet> getChange(final String changeSetName) { try { final ResultSet resultSet = this.session.execute(CQL_GET_ACTIVE_CHANGE, changeSetName); EhSupport.ensure(!resultSet.isExhausted(), "ChangeSet %s does not exist in %s.", changeSetName, this.keyspace); UUID changeSetId = null; final Map<Change, List<Change>> changes = new HashMap<>(); for (final Row row : resultSet) { changeSetId = row.getUUID("id"); final UUID changeid = row.getUUID("changeid"); final String rulesetname = row.getString("rulesetname"); final Instant activationTime = row.get("activationtime", Instant.class); final DateRange changeRange = new DateRange(row.get("start", Instant.class), row.get("end", Instant.class)); final Change newchange = new Change(changeid, rulesetname, activationTime, changeRange, getAuditForChange(row), getRuleChangeForChange(row), getValueGroupChange(row)); final List<Change> internalChanges = changes.computeIfAbsent(newchange, value -> new ArrayList<>()); internalChanges.add(newchange); } return Result.success(new ChangeSet(changeSetId, changeSetName, mergeChangesIntoSet(changes))); } catch (final Exception exception) { return Result.failure(() -> exception); } } private CassandraLoader(final Cluster cluster, final String keyspace, final String ruleSetName); }
CassandraLoader implements Loader<DecisionTreeRuleSet>, Persister, ComponentLifecycle { public Result<ChangeSet> getChange(final String changeSetName) { try { final ResultSet resultSet = this.session.execute(CQL_GET_ACTIVE_CHANGE, changeSetName); EhSupport.ensure(!resultSet.isExhausted(), "ChangeSet %s does not exist in %s.", changeSetName, this.keyspace); UUID changeSetId = null; final Map<Change, List<Change>> changes = new HashMap<>(); for (final Row row : resultSet) { changeSetId = row.getUUID("id"); final UUID changeid = row.getUUID("changeid"); final String rulesetname = row.getString("rulesetname"); final Instant activationTime = row.get("activationtime", Instant.class); final DateRange changeRange = new DateRange(row.get("start", Instant.class), row.get("end", Instant.class)); final Change newchange = new Change(changeid, rulesetname, activationTime, changeRange, getAuditForChange(row), getRuleChangeForChange(row), getValueGroupChange(row)); final List<Change> internalChanges = changes.computeIfAbsent(newchange, value -> new ArrayList<>()); internalChanges.add(newchange); } return Result.success(new ChangeSet(changeSetId, changeSetName, mergeChangesIntoSet(changes))); } catch (final Exception exception) { return Result.failure(() -> exception); } } private CassandraLoader(final Cluster cluster, final String keyspace, final String ruleSetName); static CassandraLoader instanceOf(final Cluster cluster, final String keyspace, final String ruleSetName); @Override Result<DecisionTreeRuleSet> get(); @Override void put(final DecisionTreeRuleSet ruleset); void put(final ChangeSet changeSet); Result<ChangeSet> getChange(final String changeSetName); @Override boolean test(final Result result); @Override boolean isRunning(); @Override void stop(); }
CassandraLoader implements Loader<DecisionTreeRuleSet>, Persister, ComponentLifecycle { public Result<ChangeSet> getChange(final String changeSetName) { try { final ResultSet resultSet = this.session.execute(CQL_GET_ACTIVE_CHANGE, changeSetName); EhSupport.ensure(!resultSet.isExhausted(), "ChangeSet %s does not exist in %s.", changeSetName, this.keyspace); UUID changeSetId = null; final Map<Change, List<Change>> changes = new HashMap<>(); for (final Row row : resultSet) { changeSetId = row.getUUID("id"); final UUID changeid = row.getUUID("changeid"); final String rulesetname = row.getString("rulesetname"); final Instant activationTime = row.get("activationtime", Instant.class); final DateRange changeRange = new DateRange(row.get("start", Instant.class), row.get("end", Instant.class)); final Change newchange = new Change(changeid, rulesetname, activationTime, changeRange, getAuditForChange(row), getRuleChangeForChange(row), getValueGroupChange(row)); final List<Change> internalChanges = changes.computeIfAbsent(newchange, value -> new ArrayList<>()); internalChanges.add(newchange); } return Result.success(new ChangeSet(changeSetId, changeSetName, mergeChangesIntoSet(changes))); } catch (final Exception exception) { return Result.failure(() -> exception); } } private CassandraLoader(final Cluster cluster, final String keyspace, final String ruleSetName); static CassandraLoader instanceOf(final Cluster cluster, final String keyspace, final String ruleSetName); @Override Result<DecisionTreeRuleSet> get(); @Override void put(final DecisionTreeRuleSet ruleset); void put(final ChangeSet changeSet); Result<ChangeSet> getChange(final String changeSetName); @Override boolean test(final Result result); @Override boolean isRunning(); @Override void stop(); }
@Test public void testRuleDuplicateInputCheck() { final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); assertTrue(rule.isDuplicateInputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateInputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input3"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateInputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateInputData(null)); assertFalse(rule.isDuplicateInputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray(), this.outputDriver, null, null))); assertFalse(rule.isDuplicateInputData(null)); }
public boolean isDuplicateInputData(final DecisionTreeRule other) { if (other == null || drivers.length != other.drivers.length) { return false; } for (int i = 0; i < drivers.length; i++) { final InputDriver thisValue = drivers[i]; final InputDriver otherValue = other.drivers[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; }
DecisionTreeRule implements TreeRule { public boolean isDuplicateInputData(final DecisionTreeRule other) { if (other == null || drivers.length != other.drivers.length) { return false; } for (int i = 0; i < drivers.length; i++) { final InputDriver thisValue = drivers[i]; final InputDriver otherValue = other.drivers[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; } }
DecisionTreeRule implements TreeRule { public boolean isDuplicateInputData(final DecisionTreeRule other) { if (other == null || drivers.length != other.drivers.length) { return false; } for (int i = 0; i < drivers.length; i++) { final InputDriver thisValue = drivers[i]; final InputDriver otherValue = other.drivers[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateInputData(final DecisionTreeRule other) { if (other == null || drivers.length != other.drivers.length) { return false; } for (int i = 0; i < drivers.length; i++) { final InputDriver thisValue = drivers[i]; final InputDriver otherValue = other.drivers[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateInputData(final DecisionTreeRule other) { if (other == null || drivers.length != other.drivers.length) { return false; } for (int i = 0; i < drivers.length; i++) { final InputDriver thisValue = drivers[i]; final InputDriver otherValue = other.drivers[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testRuleDuplicateEvaluationCheck() { final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), getInputDriverArray("eval1", "eval2"), this.outputDriver, null, null); assertTrue(rule.isDuplicateEvaluations(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), getInputDriverArray("eval1", "eval2"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateEvaluations(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input3"), getInputDriverArray("input1", "input2"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateEvaluations(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), getInputDriverArray("eval1"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateEvaluations(null)); assertFalse(rule.isDuplicateEvaluations(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), this.outputDriver, null, null))); assertFalse(rule.isDuplicateEvaluations(null)); }
public boolean isDuplicateEvaluations(final DecisionTreeRule other) { if (other == null || evaluations == null || other.evaluations == null || evaluations.length != other.evaluations.length) { return false; } for (int i = 0; i < evaluations.length; i++) { final InputDriver thisValue = evaluations[i]; final InputDriver otherValue = other.evaluations[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; }
DecisionTreeRule implements TreeRule { public boolean isDuplicateEvaluations(final DecisionTreeRule other) { if (other == null || evaluations == null || other.evaluations == null || evaluations.length != other.evaluations.length) { return false; } for (int i = 0; i < evaluations.length; i++) { final InputDriver thisValue = evaluations[i]; final InputDriver otherValue = other.evaluations[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; } }
DecisionTreeRule implements TreeRule { public boolean isDuplicateEvaluations(final DecisionTreeRule other) { if (other == null || evaluations == null || other.evaluations == null || evaluations.length != other.evaluations.length) { return false; } for (int i = 0; i < evaluations.length; i++) { final InputDriver thisValue = evaluations[i]; final InputDriver otherValue = other.evaluations[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateEvaluations(final DecisionTreeRule other) { if (other == null || evaluations == null || other.evaluations == null || evaluations.length != other.evaluations.length) { return false; } for (int i = 0; i < evaluations.length; i++) { final InputDriver thisValue = evaluations[i]; final InputDriver otherValue = other.evaluations[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateEvaluations(final DecisionTreeRule other) { if (other == null || evaluations == null || other.evaluations == null || evaluations.length != other.evaluations.length) { return false; } for (int i = 0; i < evaluations.length; i++) { final InputDriver thisValue = evaluations[i]; final InputDriver otherValue = other.evaluations[i]; if (!thisValue.equals(otherValue)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testRuleDuplicateOutputCheck() { final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), null, null); assertTrue(rule.isDuplicateOutputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), null, null))); assertTrue(rule.isDuplicateOutputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input3", "input4"), Collections.singletonMap("outputDriver", "result"), null, null))); assertFalse(rule.isDuplicateOutputData(null)); assertFalse(rule.isDuplicateOutputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input3", "input4"), Collections.singletonMap("outputDriver", "result1"), null, null))); assertFalse(rule.isDuplicateOutputData(new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input3", "input4"), Collections.singletonMap("outputDriver1", "result1"), null, null))); assertFalse(rule.isDuplicateOutputData( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input3", "input4"), Stream.of(new AbstractMap.SimpleEntry<>("outputDriver", "result1"), new AbstractMap.SimpleEntry<>("outputDriver2", "result2")) .collect(Collectors.toMap(AbstractMap.SimpleEntry::getKey, AbstractMap.SimpleEntry::getValue)), null, null))); }
public boolean isDuplicateOutputData(final DecisionTreeRule other) { if (other == null || outputs.size() != other.outputs.size()) { return false; } for (final Map.Entry<String, String> entry : outputs.entrySet()) { final String value = other.outputs.get(entry.getKey()); if (!entry.getValue().equals(value)) { return false; } } return true; }
DecisionTreeRule implements TreeRule { public boolean isDuplicateOutputData(final DecisionTreeRule other) { if (other == null || outputs.size() != other.outputs.size()) { return false; } for (final Map.Entry<String, String> entry : outputs.entrySet()) { final String value = other.outputs.get(entry.getKey()); if (!entry.getValue().equals(value)) { return false; } } return true; } }
DecisionTreeRule implements TreeRule { public boolean isDuplicateOutputData(final DecisionTreeRule other) { if (other == null || outputs.size() != other.outputs.size()) { return false; } for (final Map.Entry<String, String> entry : outputs.entrySet()) { final String value = other.outputs.get(entry.getKey()); if (!entry.getValue().equals(value)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateOutputData(final DecisionTreeRule other) { if (other == null || outputs.size() != other.outputs.size()) { return false; } for (final Map.Entry<String, String> entry : outputs.entrySet()) { final String value = other.outputs.get(entry.getKey()); if (!entry.getValue().equals(value)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateOutputData(final DecisionTreeRule other) { if (other == null || outputs.size() != other.outputs.size()) { return false; } for (final Map.Entry<String, String> entry : outputs.entrySet()) { final String value = other.outputs.get(entry.getKey()); if (!entry.getValue().equals(value)) { return false; } } return true; } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testDuplicateDateRange() { final Instant startTime = Instant.now().minus(30, ChronoUnit.DAYS); final Instant endTime = Instant.now().plus(180, ChronoUnit.DAYS); final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, endTime); assertFalse(rule.isDuplicateDateRange(null)); assertTrue(rule.isDuplicateDateRange( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, endTime))); assertTrue(rule.isDuplicateDateRange( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input3", "input4"), Collections.singletonMap("outputDriver2", "result2"), startTime, endTime))); assertFalse(rule.isDuplicateDateRange( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), null, endTime))); assertFalse(rule.isDuplicateDateRange( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, null))); assertFalse(rule.isDuplicateDateRange( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), Instant.now(), endTime))); }
public boolean isDuplicateDateRange(final DecisionTreeRule other) { return other != null && start.equals(other.start) && end.equals(other.end); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateDateRange(final DecisionTreeRule other) { return other != null && start.equals(other.start) && end.equals(other.end); } }
DecisionTreeRule implements TreeRule { public boolean isDuplicateDateRange(final DecisionTreeRule other) { return other != null && start.equals(other.start) && end.equals(other.end); } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateDateRange(final DecisionTreeRule other) { return other != null && start.equals(other.start) && end.equals(other.end); } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateDateRange(final DecisionTreeRule other) { return other != null && start.equals(other.start) && end.equals(other.end); } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testDuplicateRuleCheck() { final Instant startTime = Instant.now().minus(30, ChronoUnit.DAYS); final Instant endTime = Instant.now().plus(180, ChronoUnit.DAYS); final DecisionTreeRule rule = new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, endTime); assertFalse(rule.isDuplicateRule(null)); assertTrue(rule.isDuplicateRule( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, endTime))); assertFalse(rule.isDuplicateRule( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input3"), Collections.singletonMap("outputDriver", "result"), startTime, endTime))); assertFalse(rule.isDuplicateRule( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result1"), startTime, endTime))); assertFalse(rule.isDuplicateRule( new DecisionTreeRule(new UUID(0, 1), UUID.randomUUID(), getInputDriverArray("input1", "input2"), Collections.singletonMap("outputDriver", "result"), startTime, null))); }
public boolean isDuplicateRule(final DecisionTreeRule other) { if (other == null) { return false; } if (evaluations != null || other.evaluations != null) { return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other) && isDuplicateEvaluations(other); } return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateRule(final DecisionTreeRule other) { if (other == null) { return false; } if (evaluations != null || other.evaluations != null) { return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other) && isDuplicateEvaluations(other); } return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other); } }
DecisionTreeRule implements TreeRule { public boolean isDuplicateRule(final DecisionTreeRule other) { if (other == null) { return false; } if (evaluations != null || other.evaluations != null) { return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other) && isDuplicateEvaluations(other); } return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other); } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateRule(final DecisionTreeRule other) { if (other == null) { return false; } if (evaluations != null || other.evaluations != null) { return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other) && isDuplicateEvaluations(other); } return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other); } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRule implements TreeRule { public boolean isDuplicateRule(final DecisionTreeRule other) { if (other == null) { return false; } if (evaluations != null || other.evaluations != null) { return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other) && isDuplicateEvaluations(other); } return isDuplicateInputData(other) && isDuplicateOutputData(other) && isDuplicateDateRange(other); } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testReplaceDriversFromCache() { final DecisionTreeRule decisionTreeRule = new DecisionTreeRule(new UUID(0, 1), new UUID(0, 2), getInputDriverArray("input1", "input2"), this.outputDriver, null, null); final DriverCache cache = new DriverCache(); cache.put(new StringDriver("input1")); final InputDriver originalDriver1 = decisionTreeRule.getDrivers()[0]; final InputDriver cachedDriver1 = cache.get("input1", InputValueType.STRING); assertFalse(originalDriver1 == cachedDriver1); decisionTreeRule.replaceDriversFromCache(cache); assertTrue(decisionTreeRule.getDrivers()[0] == cachedDriver1); assertEquals(cache.get("input2", InputValueType.STRING), decisionTreeRule.getDrivers()[1]); }
void replaceDriversFromCache(final DriverCache cache) { for (int i = 0; i < drivers.length; i++) { final InputDriver driver = drivers[i]; InputDriver cachedDriver = cache.get(driver.getValue(), driver.getType()); if (cachedDriver == null) { cache.put(driver); cachedDriver = cache.get(driver.getValue(), driver.getType()); } drivers[i] = cachedDriver; } }
DecisionTreeRule implements TreeRule { void replaceDriversFromCache(final DriverCache cache) { for (int i = 0; i < drivers.length; i++) { final InputDriver driver = drivers[i]; InputDriver cachedDriver = cache.get(driver.getValue(), driver.getType()); if (cachedDriver == null) { cache.put(driver); cachedDriver = cache.get(driver.getValue(), driver.getType()); } drivers[i] = cachedDriver; } } }
DecisionTreeRule implements TreeRule { void replaceDriversFromCache(final DriverCache cache) { for (int i = 0; i < drivers.length; i++) { final InputDriver driver = drivers[i]; InputDriver cachedDriver = cache.get(driver.getValue(), driver.getType()); if (cachedDriver == null) { cache.put(driver); cachedDriver = cache.get(driver.getValue(), driver.getType()); } drivers[i] = cachedDriver; } } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); }
DecisionTreeRule implements TreeRule { void replaceDriversFromCache(final DriverCache cache) { for (int i = 0; i < drivers.length; i++) { final InputDriver driver = drivers[i]; InputDriver cachedDriver = cache.get(driver.getValue(), driver.getType()); if (cachedDriver == null) { cache.put(driver); cachedDriver = cache.get(driver.getValue(), driver.getType()); } drivers[i] = cachedDriver; } } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRule implements TreeRule { void replaceDriversFromCache(final DriverCache cache) { for (int i = 0; i < drivers.length; i++) { final InputDriver driver = drivers[i]; InputDriver cachedDriver = cache.get(driver.getValue(), driver.getType()); if (cachedDriver == null) { cache.put(driver); cachedDriver = cache.get(driver.getValue(), driver.getType()); } drivers[i] = cachedDriver; } } DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final InputDriver[] evaluations, final Map<String, String> outputs, final Instant start, final Instant end); DecisionTreeRule(final UUID ruleIdentifier, final UUID ruleCode, final InputDriver[] drivers, final Map<String, String> outputs, final Instant start, final Instant end); boolean isActiveAt(final Instant time); @Override UUID getRuleIdentifier(); @Override InputDriver[] getDrivers(); @Override Optional<InputDriver[]> getEvaluations(); @Override Map<String, String> getOutputs(); @Override DateRange getRange(); Instant getStart(); Instant getEnd(); boolean isDuplicateRule(final DecisionTreeRule other); boolean isDuplicateInputData(final DecisionTreeRule other); boolean isDuplicateEvaluations(final DecisionTreeRule other); boolean isDuplicateOutputData(final DecisionTreeRule other); boolean isDuplicateDateRange(final DecisionTreeRule other); long getRuleWeight(); @Override UUID getRuleCode(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final int INITIAL_WEIGHTED_VALUE; static final Instant EPOCH; static final Instant MAX; }
@Test public void testEquality() { final List<String> driverNames = Arrays.asList("driver1", "driver2"); final DecisionTreeRuleSet ruleSet = new DecisionTreeRuleSet("TestName", null, driverNames); assertEquals(ruleSet, ruleSet); assertEquals(new DecisionTreeRuleSet("TestName", null, driverNames), ruleSet); assertNotEquals(new DecisionTreeRuleSet("NotTestName", null, driverNames), ruleSet); assertNotEquals(1, ruleSet); assertNotEquals(ruleSet, null); assertEquals(new DecisionTreeRuleSet("TestName", null, driverNames).hashCode(), ruleSet.hashCode()); assertNotEquals(new DecisionTreeRuleSet("NotTestName", null, driverNames).hashCode(), ruleSet.hashCode()); }
@Override public int hashCode() { return name.hashCode(); }
DecisionTreeRuleSet { @Override public int hashCode() { return name.hashCode(); } }
DecisionTreeRuleSet { @Override public int hashCode() { return name.hashCode(); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); }
DecisionTreeRuleSet { @Override public int hashCode() { return name.hashCode(); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRuleSet { @Override public int hashCode() { return name.hashCode(); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test(expected = IllegalArgumentException.class) public void testTooManyDriversToWeightedDrivers() { final List<String> driverNames = IntStream.range(1, 33).mapToObj(String::valueOf).collect(Collectors.toList()); DecisionTreeRuleSet.convertNamesToWeightedDrivers(driverNames); }
public static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames) { EhSupport.ensureArg(driverNames.size() < 32, "Maximum number of drivers is 31"); return IntStream.range(0, driverNames.size()) .mapToObj(counter -> new WeightedDriver(driverNames.get(counter), 1 << driverNames.size() - counter)) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); }
DecisionTreeRuleSet { public static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames) { EhSupport.ensureArg(driverNames.size() < 32, "Maximum number of drivers is 31"); return IntStream.range(0, driverNames.size()) .mapToObj(counter -> new WeightedDriver(driverNames.get(counter), 1 << driverNames.size() - counter)) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); } }
DecisionTreeRuleSet { public static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames) { EhSupport.ensureArg(driverNames.size() < 32, "Maximum number of drivers is 31"); return IntStream.range(0, driverNames.size()) .mapToObj(counter -> new WeightedDriver(driverNames.get(counter), 1 << driverNames.size() - counter)) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); }
DecisionTreeRuleSet { public static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames) { EhSupport.ensureArg(driverNames.size() < 32, "Maximum number of drivers is 31"); return IntStream.range(0, driverNames.size()) .mapToObj(counter -> new WeightedDriver(driverNames.get(counter), 1 << driverNames.size() - counter)) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRuleSet { public static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames) { EhSupport.ensureArg(driverNames.size() < 32, "Maximum number of drivers is 31"); return IntStream.range(0, driverNames.size()) .mapToObj(counter -> new WeightedDriver(driverNames.get(counter), 1 << driverNames.size() - counter)) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test(expected = UnsupportedOperationException.class) public void testingImmutableValueGroups() { final DecisionTreeRuleSet commisssionRuleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); commisssionRuleSet.getValueGroups().clear(); }
public Set<ValueGroup> getValueGroups() { return groups.values().stream() .collect(collectingAndThen(Collectors.toSet(), Collections::unmodifiableSet)); }
DecisionTreeRuleSet { public Set<ValueGroup> getValueGroups() { return groups.values().stream() .collect(collectingAndThen(Collectors.toSet(), Collections::unmodifiableSet)); } }
DecisionTreeRuleSet { public Set<ValueGroup> getValueGroups() { return groups.values().stream() .collect(collectingAndThen(Collectors.toSet(), Collections::unmodifiableSet)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); }
DecisionTreeRuleSet { public Set<ValueGroup> getValueGroups() { return groups.values().stream() .collect(collectingAndThen(Collectors.toSet(), Collections::unmodifiableSet)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRuleSet { public Set<ValueGroup> getValueGroups() { return groups.values().stream() .collect(collectingAndThen(Collectors.toSet(), Collections::unmodifiableSet)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test(expected = UnsupportedOperationException.class) public void testingImmutableDrivers() { final DecisionTreeRuleSet commisssionRuleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); commisssionRuleSet.getDriverNames().clear(); }
public List<String> getDriverNames() { return driverNames.stream().map(WeightedDriver::getName) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); }
DecisionTreeRuleSet { public List<String> getDriverNames() { return driverNames.stream().map(WeightedDriver::getName) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); } }
DecisionTreeRuleSet { public List<String> getDriverNames() { return driverNames.stream().map(WeightedDriver::getName) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); }
DecisionTreeRuleSet { public List<String> getDriverNames() { return driverNames.stream().map(WeightedDriver::getName) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRuleSet { public List<String> getDriverNames() { return driverNames.stream().map(WeightedDriver::getName) .collect(collectingAndThen(Collectors.toList(), Collections::unmodifiableList)); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test(expected = IllegalArgumentException.class) public void cannotAddNullRuleChange() { testConstruction(); getBean().addRuleChange((RuleChange) null); }
public boolean addRuleChange(final RuleChange change) { EhSupport.ensureArg(change != null, "Cannot add a null rule change"); return this.ruleChanges.add(change); }
Change implements TreeChange { public boolean addRuleChange(final RuleChange change) { EhSupport.ensureArg(change != null, "Cannot add a null rule change"); return this.ruleChanges.add(change); } }
Change implements TreeChange { public boolean addRuleChange(final RuleChange change) { EhSupport.ensureArg(change != null, "Cannot add a null rule change"); return this.ruleChanges.add(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); }
Change implements TreeChange { public boolean addRuleChange(final RuleChange change) { EhSupport.ensureArg(change != null, "Cannot add a null rule change"); return this.ruleChanges.add(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
Change implements TreeChange { public boolean addRuleChange(final RuleChange change) { EhSupport.ensureArg(change != null, "Cannot add a null rule change"); return this.ruleChanges.add(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test(expected = UnsupportedOperationException.class) public void testingImmutableEvaluationNames() { final DecisionTreeRuleSet commisssionRuleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); commisssionRuleSet.getEvaluationNames().clear(); }
public List<String> getEvaluationNames() { return Collections.unmodifiableList(evaluationNames); }
DecisionTreeRuleSet { public List<String> getEvaluationNames() { return Collections.unmodifiableList(evaluationNames); } }
DecisionTreeRuleSet { public List<String> getEvaluationNames() { return Collections.unmodifiableList(evaluationNames); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); }
DecisionTreeRuleSet { public List<String> getEvaluationNames() { return Collections.unmodifiableList(evaluationNames); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRuleSet { public List<String> getEvaluationNames() { return Collections.unmodifiableList(evaluationNames); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test public void testFindingInputDrivers() { final DecisionTreeRuleSet commisssionRuleSet = CommisionRuleSetSupplier.getCommissionRuleSetWithRegex().build(); List<InputDriver> driversByType = commisssionRuleSet.getDriversByType(InputValueType.STRING); assertNotNull(driversByType); assertEquals(11, driversByType.size()); assertThat(driversByType, IsCollectionContaining.hasItems(new StringDriver("VOICE"), new StringDriver("RATE"), new StringDriver("UK"), new StringDriver("*"), new StringDriver("CME"), new StringDriver("INDEX"), new StringDriver("S&P"), new StringDriver("US"), new StringDriver("ED"), new StringDriver("NDK"))); driversByType = commisssionRuleSet.getDriversByType(InputValueType.REGEX); assertNotNull(driversByType); assertEquals(3, driversByType.size()); assertThat(driversByType, IsCollectionContaining.hasItems(new RegexDriver("AP.?C"), new RegexDriver("C.?E"), new RegexDriver("^[A-Z]{1,2}[A-Z][0-9]{1,2}$"))); }
public List<InputDriver> getDriversByType(final InputValueType type) { return cache.findByInputDriverType(type); }
DecisionTreeRuleSet { public List<InputDriver> getDriversByType(final InputValueType type) { return cache.findByInputDriverType(type); } }
DecisionTreeRuleSet { public List<InputDriver> getDriversByType(final InputValueType type) { return cache.findByInputDriverType(type); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); }
DecisionTreeRuleSet { public List<InputDriver> getDriversByType(final InputValueType type) { return cache.findByInputDriverType(type); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
DecisionTreeRuleSet { public List<InputDriver> getDriversByType(final InputValueType type) { return cache.findByInputDriverType(type); } DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames); DecisionTreeRuleSet(final String name, final Map<UUID, DecisionTreeRule> rules, final List<String> driverNames, final List<String> evaluationNames, final DriverCache cache, final Set<ValueGroup> valueGroups); static List<WeightedDriver> convertNamesToWeightedDrivers(final List<String> driverNames); String getName(); Map<UUID, DecisionTreeRule> getRules(); List<String> getDriverNames(); List<String> getEvaluationNames(); List<WeightedDriver> getWeightedDrivers(); List<InputDriver> getDriversByType(final InputValueType type); Set<ValueGroup> getValueGroups(); DriverCache getDriverCache(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
@Test public void equalsCorrect() { final UUID uuid = new UUID(0, 1); final DateRange range = new DateRange(NOW, Instant.MAX); final ValueGroup group = new ValueGroup(uuid, "test-group", Arrays.asList("input1", "input2"), range); assertTrue(group.equals(group)); assertFalse(group.equals(null)); assertFalse(group.equals(Integer.parseInt("1"))); ValueGroup other = new ValueGroup(new UUID(0, 1), "test-group", Arrays.asList("input1", "input2"), new DateRange(NOW, Instant.MAX)); assertTrue(group.equals(other)); other = new ValueGroup(new UUID(0, 2), "test-group", Arrays.asList("input1", "input2"), new DateRange(NOW, Instant.MAX)); assertFalse(group.equals(other)); other = new ValueGroup(new UUID(0, 1), "test-group1", Arrays.asList("input1", "input2"), new DateRange(NOW, Instant.MAX)); assertFalse(group.equals(other)); other = new ValueGroup(new UUID(0, 1), "test-group", Arrays.asList("input1"), new DateRange(NOW, Instant.MAX)); assertFalse(group.equals(other)); other = new ValueGroup(new UUID(0, 1), "test-group", Arrays.asList("input1", "input2"), ValueGroup.DEFAULT_DATE_RANGE); assertFalse(group.equals(other)); }
@Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } final ValueGroup otherGroup = (ValueGroup) other; return getId().equals(otherGroup.getId()) && getName().equals(otherGroup.getName()) && getValues().equals(otherGroup.getValues()) && getRange().equals(otherGroup.getRange()); }
ValueGroup implements TreeValueGroup { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } final ValueGroup otherGroup = (ValueGroup) other; return getId().equals(otherGroup.getId()) && getName().equals(otherGroup.getName()) && getValues().equals(otherGroup.getValues()) && getRange().equals(otherGroup.getRange()); } }
ValueGroup implements TreeValueGroup { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } final ValueGroup otherGroup = (ValueGroup) other; return getId().equals(otherGroup.getId()) && getName().equals(otherGroup.getName()) && getValues().equals(otherGroup.getValues()) && getRange().equals(otherGroup.getRange()); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); }
ValueGroup implements TreeValueGroup { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } final ValueGroup otherGroup = (ValueGroup) other; return getId().equals(otherGroup.getId()) && getName().equals(otherGroup.getName()) && getValues().equals(otherGroup.getValues()) && getRange().equals(otherGroup.getRange()); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); @Override UUID getId(); @Override String getName(); @Override List<String> getValues(); @Override DateRange getRange(); void updateValues(final List<String> amended); void setNewRuleData(final String driverName, final List<UUID> ruleCodes); List<UUID> getRuleCodes(); String getDriverName(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
ValueGroup implements TreeValueGroup { @Override public boolean equals(final Object other) { if (this == other) { return true; } if (other == null || this.getClass() != other.getClass()) { return false; } final ValueGroup otherGroup = (ValueGroup) other; return getId().equals(otherGroup.getId()) && getName().equals(otherGroup.getName()) && getValues().equals(otherGroup.getValues()) && getRange().equals(otherGroup.getRange()); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); @Override UUID getId(); @Override String getName(); @Override List<String> getValues(); @Override DateRange getRange(); void updateValues(final List<String> amended); void setNewRuleData(final String driverName, final List<UUID> ruleCodes); List<UUID> getRuleCodes(); String getDriverName(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final DateRange DEFAULT_DATE_RANGE; }
@Test public void hashCodeCorrect() { final UUID uuid = new UUID(0, 1); final DateRange range = new DateRange(NOW, Instant.MAX); final ValueGroup group = new ValueGroup(uuid, "test-group", Arrays.asList("input1", "input2"), range); final ValueGroup other = new ValueGroup(new UUID(0, 1), "test-group", Arrays.asList("input1", "input2"), new DateRange(NOW, Instant.MAX)); assertTrue(group.hashCode() == other.hashCode()); }
@Override public int hashCode() { return getId().hashCode() + getName().hashCode() + getValues().hashCode() + getRange().hashCode(); }
ValueGroup implements TreeValueGroup { @Override public int hashCode() { return getId().hashCode() + getName().hashCode() + getValues().hashCode() + getRange().hashCode(); } }
ValueGroup implements TreeValueGroup { @Override public int hashCode() { return getId().hashCode() + getName().hashCode() + getValues().hashCode() + getRange().hashCode(); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); }
ValueGroup implements TreeValueGroup { @Override public int hashCode() { return getId().hashCode() + getName().hashCode() + getValues().hashCode() + getRange().hashCode(); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); @Override UUID getId(); @Override String getName(); @Override List<String> getValues(); @Override DateRange getRange(); void updateValues(final List<String> amended); void setNewRuleData(final String driverName, final List<UUID> ruleCodes); List<UUID> getRuleCodes(); String getDriverName(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
ValueGroup implements TreeValueGroup { @Override public int hashCode() { return getId().hashCode() + getName().hashCode() + getValues().hashCode() + getRange().hashCode(); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); @Override UUID getId(); @Override String getName(); @Override List<String> getValues(); @Override DateRange getRange(); void updateValues(final List<String> amended); void setNewRuleData(final String driverName, final List<UUID> ruleCodes); List<UUID> getRuleCodes(); String getDriverName(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final DateRange DEFAULT_DATE_RANGE; }
@Test public void toStringCorrect() { final UUID uuid = new UUID(0, 1); final DateRange range = new DateRange(NOW, Instant.MAX); final ValueGroup group = new ValueGroup(uuid, "test-group", Arrays.asList("input1", "input2"), range); Assert.assertEquals(GroupDriver.VG_PREFIX + new UUID(0, 1), group.toString()); }
@Override public String toString() { return GroupDriver.VG_PREFIX + getId(); }
ValueGroup implements TreeValueGroup { @Override public String toString() { return GroupDriver.VG_PREFIX + getId(); } }
ValueGroup implements TreeValueGroup { @Override public String toString() { return GroupDriver.VG_PREFIX + getId(); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); }
ValueGroup implements TreeValueGroup { @Override public String toString() { return GroupDriver.VG_PREFIX + getId(); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); @Override UUID getId(); @Override String getName(); @Override List<String> getValues(); @Override DateRange getRange(); void updateValues(final List<String> amended); void setNewRuleData(final String driverName, final List<UUID> ruleCodes); List<UUID> getRuleCodes(); String getDriverName(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); }
ValueGroup implements TreeValueGroup { @Override public String toString() { return GroupDriver.VG_PREFIX + getId(); } ValueGroup(final String name, final List<String> values); ValueGroup(final UUID id, final String name, final List<String> values, final DateRange range); @Override UUID getId(); @Override String getName(); @Override List<String> getValues(); @Override DateRange getRange(); void updateValues(final List<String> amended); void setNewRuleData(final String driverName, final List<UUID> ruleCodes); List<UUID> getRuleCodes(); String getDriverName(); @Override boolean equals(final Object other); @Override int hashCode(); @Override String toString(); static final DateRange DEFAULT_DATE_RANGE; }
@Test public void testRuleSetBuilderFactory() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> instance = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); assertNotNull(instance); final DecisionTreeRuleSet ruleSet = instance.build(); assertNotNull(ruleSet); assertEquals("", ruleSet.getName()); }
public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testRuleSetBuilderFactoryWithName() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> instance = RuleSetBuilder.creator("TestRuleSetName", Arrays.asList("input1", "input2", "input3")); assertNotNull(instance); final DecisionTreeRuleSet ruleSet = instance.build(); assertNotNull(ruleSet); assertEquals("TestRuleSetName", ruleSet.getName()); }
public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testConstructingSimpleRuleSet() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); ruleSetBuilder.with(RuleSetBuilder::setName, "testSimpleRuleSet"); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::setId, new UUID(0, 3)) .with(RuleBuilder::setCode, new UUID(0, 3)) .with(RuleBuilder::input, Arrays.asList("input1", "input2", "input4")) .with(RuleBuilder::output, Collections.singletonList("outputDriver:result"))); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); assertNotNull(ruleSet); assertEquals(1L, ruleSet.getRules().size()); assertEquals("testSimpleRuleSet", ruleSet.getName()); final DecisionTreeRule rule = ruleSet.getRules().get(new UUID(0, 3)); assertNotNull(rule); assertEquals(new UUID(0, 3), rule.getRuleIdentifier()); assertEquals(3, rule.getDrivers().length); assertEquals(Arrays.asList("input1", "input2", "input3"), ruleSet.getDriverNames()); assertEquals("result", rule.getOutputs().get("outputDriver")); }
public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testConstructingRuleSetWithEvaluations() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); ruleSetBuilder.with(RuleSetBuilder::setName, "testSimpleRuleSet"); ruleSetBuilder.with(RuleSetBuilder::setEvaluationNames, Collections.singletonList("Eval1")); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::setId, new UUID(0, 3)) .with(RuleBuilder::setCode, new UUID(0, 3)) .with(RuleBuilder::input, Arrays.asList("input1", "input2", "input4")) .with(RuleBuilder::evaluations, Collections.singletonList("Eval1")) .with(RuleBuilder::output, Collections.singletonList("outputDriver:result"))); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); assertNotNull(ruleSet); assertThat(ruleSet.getRules(), is(notNullValue())); assertThat(ruleSet.getRules().size(), is(1)); assertThat(ruleSet.getName(), is("testSimpleRuleSet")); assertThat(ruleSet.getEvaluationNames(), is(notNullValue())); assertThat(ruleSet.getEvaluationNames(), hasSize(1)); assertThat(ruleSet.getEvaluationNames(), hasItem("Eval1")); final DecisionTreeRule rule = ruleSet.getRules().get(new UUID(0, 3)); assertThat(rule, is(notNullValue())); assertThat(rule.getRuleIdentifier(), is(new UUID(0, 3))); assertThat(Arrays.asList(rule.getDrivers()), hasSize(3)); assertThat(ruleSet.getDriverNames(), contains("input1", "input2", "input3")); assertThat(rule.getEvaluations().isPresent(), is(true)); assertThat(Arrays.asList(rule.getEvaluations().get()), hasItem(new StringDriver("Eval1"))); assertThat(rule.getOutputs().get("outputDriver"), is("result")); }
public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testConstructingSimpleRegexRuleSet() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::input, Arrays.asList("input1", "inp.?t2", "input4.*")) .with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result"))); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); assertNotNull(ruleSet); assertEquals(1L, ruleSet.getRules().size()); }
public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void removeRuleChange() { addRuleChange(); assertThat(getBean().getRuleChanges(), hasSize(2)); final Instant start = NOW.minus(Period.ofWeeks(-1)); final Instant end = start.plus(Period.ofWeeks(5)); final InputDriver[] drivers = getInputDriverArray("Test5", "Test6", "Test7"); final Map<String, String> outputs = Collections.singletonMap("outputDriver", "result"); DecisionTreeRule rule = new DecisionTreeRule(UNKNOWN_ID, new UUID(0, 4), drivers, outputs, start, end); RuleChange ruleChange = new RuleChange(Type.ORIGINAL, rule); getBean().removeRuleChange(ruleChange); assertThat(getBean().getRuleChanges(), hasSize(2)); assertThat(getBean().getValueGroupChanges(), hasSize(1)); rule = new DecisionTreeRule(UNKNOWN_ID, new UUID(0, 4), drivers, outputs, start, end); ruleChange = new RuleChange(Type.ORIGINAL, rule); getBean().removeRuleChange(ruleChange); assertThat(getBean().getRuleChanges(), hasSize(2)); assertThat(getBean().getValueGroupChanges(), hasSize(1)); rule = new DecisionTreeRule(ADDED_ID, new UUID(0, 4), drivers, outputs, start, end); ruleChange = new RuleChange(Type.ORIGINAL, rule); getBean().removeRuleChange(ruleChange); assertThat(getBean().getRuleChanges(), hasSize(2)); assertThat(getBean().getValueGroupChanges(), hasSize(1)); rule = new DecisionTreeRule(ADDED_ID, new UUID(0, 4), drivers, outputs, start, end); ruleChange = new RuleChange(Type.NEW, rule); getBean().removeRuleChange(ruleChange); assertThat(getBean().getRuleChanges(), hasSize(1)); assertThat(getBean().getValueGroupChanges(), hasSize(1)); }
public boolean removeRuleChange(final RuleChange change) { return this.ruleChanges.remove(change); }
Change implements TreeChange { public boolean removeRuleChange(final RuleChange change) { return this.ruleChanges.remove(change); } }
Change implements TreeChange { public boolean removeRuleChange(final RuleChange change) { return this.ruleChanges.remove(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); }
Change implements TreeChange { public boolean removeRuleChange(final RuleChange change) { return this.ruleChanges.remove(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
Change implements TreeChange { public boolean removeRuleChange(final RuleChange change) { return this.ruleChanges.remove(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void testConstructingSimpleValueGroupRuleSetWithoutValueGroups() { final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::input, Arrays.asList("VG:VG1:input1:input2", "VG:VG2:input3:input4", "VG:VG3:input5:input6:VG:VG4:input7:input8")) .with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result"))); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); assertNotNull(ruleSet); assertEquals(1L, ruleSet.getRules().size()); final Set<ValueGroup> groups = ruleSet.getValueGroups(); assertEquals(4, groups.size()); final DriverCache cache = ruleSet.getDriverCache(); final List<InputDriver> drivers = cache.findByInputDriverType(InputValueType.VALUE_GROUP); assertEquals(8, drivers.size()); InputDriver driver = cache.get("VG1", InputValueType.VALUE_GROUP); assertNotNull(driver); assertTrue(driver.evaluate("input1")); assertTrue(driver.evaluate("input2")); driver = cache.get("VG2", InputValueType.VALUE_GROUP); assertTrue(driver.evaluate("input3")); assertTrue(driver.evaluate("input4")); driver = cache.get("VG3", InputValueType.VALUE_GROUP); assertTrue(driver.evaluate("input5")); assertTrue(driver.evaluate("input6")); assertTrue(driver.evaluate("input7")); assertTrue(driver.evaluate("input8")); driver = cache.get("VG4", InputValueType.VALUE_GROUP); assertTrue(driver.evaluate("input7")); assertTrue(driver.evaluate("input8")); }
public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void constructsValueGroupRuleSetWithSpecifiedGroups() { final Set<ValueGroup> groups = new HashSet<>(4); final UUID vg1 = new UUID(0, 1); final UUID vg2 = new UUID(0, 2); final UUID vg3 = new UUID(0, 3); final UUID vg4 = new UUID(0, 4); ValueGroup group = new ValueGroup(vg1, "VG1", Arrays.asList("input1", "input2"), ValueGroup.DEFAULT_DATE_RANGE); groups.add(group); group = new ValueGroup(vg2, "VG2", Arrays.asList("input3", "input4"), ValueGroup.DEFAULT_DATE_RANGE); groups.add(group); group = new ValueGroup(vg3, "VG3", Arrays.asList(GroupDriver.VG_PREFIX + vg4, "input5", "input6"), ValueGroup.DEFAULT_DATE_RANGE); groups.add(group); group = new ValueGroup(vg4, "VG4", Arrays.asList("input7", "input8"), ValueGroup.DEFAULT_DATE_RANGE); groups.add(group); final Builder<RuleSetBuilder, DecisionTreeRuleSet> ruleSetBuilder = RuleSetBuilder.creator(Arrays.asList("input1", "input2", "input3")); ruleSetBuilder.with(RuleSetBuilder::rule, RuleBuilder.creator() .with(RuleBuilder::input, Arrays.asList(GroupDriver.VG_PREFIX + vg1, GroupDriver.VG_PREFIX + vg2, GroupDriver.VG_PREFIX + vg3)) .with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result"))); ruleSetBuilder.with(RuleSetBuilder::groups, groups); final DecisionTreeRuleSet ruleSet = ruleSetBuilder.build(); assertNotNull(ruleSet); assertEquals(1L, ruleSet.getRules().size()); final DriverCache cache = ruleSet.getDriverCache(); final List<InputDriver> groupDrivers = cache.findByInputDriverType(InputValueType.VALUE_GROUP); assertThat(groupDrivers, hasSize(4)); GroupDriver added = (GroupDriver) groupDrivers.stream().filter(inputDriver -> vg1.toString().equals(inputDriver.getValue())).findFirst().get(); assertNotNull(added); assertThat(Arrays.stream(added.getSubDrivers(false)).map(InputDriver::getValue).collect(Collectors.toList()), containsInAnyOrder("input1", "input2")); assertTrue(added.evaluate("input1")); assertTrue(added.evaluate("input2")); added = (GroupDriver) groupDrivers.stream().filter(inputDriver -> vg2.toString().equals(inputDriver.getValue())).findFirst().get(); assertNotNull(added); assertThat(Arrays.stream(added.getSubDrivers(false)).map(InputDriver::getValue).collect(Collectors.toList()), containsInAnyOrder("input3", "input4")); assertTrue(added.evaluate("input3")); assertTrue(added.evaluate("input4")); added = (GroupDriver) groupDrivers.stream().filter(inputDriver -> vg3.toString().equals(inputDriver.getValue())).findFirst().get(); assertNotNull(added); assertThat(Arrays.stream(added.getSubDrivers(false)).map(InputDriver::getValue).collect(Collectors.toList()), containsInAnyOrder("input5", "input6", vg4.toString())); assertTrue(added.evaluate("input5")); assertTrue(added.evaluate("input6")); assertTrue(added.evaluate("input7")); assertTrue(added.evaluate("input8")); added = (GroupDriver) groupDrivers.stream().filter(inputDriver -> vg4.toString().equals(inputDriver.getValue())).findFirst().get(); assertNotNull(added); assertThat(Arrays.stream(added.getSubDrivers(false)).map(InputDriver::getValue).collect(Collectors.toList()), containsInAnyOrder("input7", "input8")); assertTrue(added.evaluate("input7")); assertTrue(added.evaluate("input8")); }
public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames) { return creator("", driverNames); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testCreatingBasicValueGroupDriversInCache() { final DriverCache cache = new DriverCache(); final Set<ValueGroup> valueGroups = new HashSet<>(1); final ValueGroup group = new ValueGroup("vg1", Arrays.asList("input1", "input2", "input3")); valueGroups.add(group); RuleSetBuilder.addValueGroupsToDriverCache(cache, valueGroups); assertTrue(cache.contains(GroupDriver.VG_PREFIX + group.getId())); assertTrue(cache.contains("input1")); assertTrue(cache.contains("input2")); assertTrue(cache.contains("input3")); final InputDriver valueGroup = cache.get(group.getId().toString(), InputValueType.VALUE_GROUP); assertTrue(valueGroup.evaluate("input1")); assertTrue(valueGroup.evaluate("input2")); assertTrue(valueGroup.evaluate("input3")); assertFalse(valueGroup.evaluate("input4")); }
public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testCreatingValueGroupsOfValueGroupsInCache() { final DriverCache cache = new DriverCache(); final Set<ValueGroup> valueGroups = new HashSet<>(2); final ValueGroup vg11 = new ValueGroup("vg1.1", Arrays.asList("input1.1", "input1.2")); valueGroups.add(vg11); final ValueGroup vg1 = new ValueGroup("vg1", Arrays.asList("input1", "input2", GroupDriver.VG_PREFIX + vg11.getId())); valueGroups.add(vg1); RuleSetBuilder.addValueGroupsToDriverCache(cache, valueGroups); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg1.getId())); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg11.getId())); final InputDriver driverVg1 = cache.get(vg1.getId().toString(), InputValueType.VALUE_GROUP); assertTrue(driverVg1.evaluate("input1.1")); assertTrue(driverVg1.evaluate("input1.2")); assertTrue(driverVg1.evaluate("input1")); assertFalse(driverVg1.evaluate("item1.3")); }
public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testRecursiveDefinitionsOfSelf() { final DriverCache cache = new DriverCache(); final Set<ValueGroup> valueGroups = new HashSet<>(2); final ValueGroup vg1 = new ValueGroup("vg1", Arrays.asList("input1", "input2", "VG:vg1.1")); valueGroups.add(vg1); final ValueGroup vg11 = new ValueGroup("vg1.1", Arrays.asList("input1.1", "input1.2")); valueGroups.add(vg11); RuleSetBuilder.addValueGroupsToDriverCache(cache, valueGroups); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg1.getId())); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg11.getId())); }
public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testRecursiveDefinitionsOfParent() { final DriverCache cache = new DriverCache(); final Set<ValueGroup> valueGroups = new HashSet<>(2); final ValueGroup vg1 = new ValueGroup("vg1", Arrays.asList("input1", "input2", "VG:vg1.1")); valueGroups.add(vg1); final ValueGroup vg11 = new ValueGroup("vg1.1", Arrays.asList("input1.1", "input1.2", "VG:vg1")); valueGroups.add(vg11); RuleSetBuilder.addValueGroupsToDriverCache(cache, valueGroups); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg1.getId())); assertTrue(cache.contains(GroupDriver.VG_PREFIX + vg11.getId())); }
public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testSameGroupNameAsStringValue() { final DriverCache cache = new DriverCache(); final Set<ValueGroup> valueGroups = new HashSet<>(2); final ValueGroup group = new ValueGroup("test", Arrays.asList("test", "input1", "input2")); valueGroups.add(group); RuleSetBuilder.addValueGroupsToDriverCache(cache, valueGroups); assertTrue(cache.contains(GroupDriver.VG_PREFIX + group.getId())); assertTrue(cache.contains("test")); final InputDriver testGroup = cache.get(group.getId().toString(), InputValueType.VALUE_GROUP); assertTrue(testGroup.evaluate("test")); }
public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
RuleSetBuilder { public static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups) { valueGroups.forEach(valueGroup -> { GroupDriver existingDriver = getGroupDriver(cache, valueGroup.getId().toString()); if (existingDriver == null) { existingDriver = new GroupDriver(valueGroup.getId().toString(), Collections.emptyList()); } final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); existingDriver.setSubValues(inputDriversFromStrings); cache.put(existingDriver); }); valueGroups.forEach(valueGroup -> { final List<InputDriver> inputDriversFromStrings = getInputDriversFromStrings(cache, valueGroup); getGroupDriver(cache, valueGroup.getId().toString()) .setSubValues(inputDriversFromStrings); }); } private RuleSetBuilder(final String name, final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final List<String> driverNames); static Builder<RuleSetBuilder, DecisionTreeRuleSet> creator(final String name, final List<String> driverNames); static void addValueGroupsToDriverCache(final DriverCache cache, final Collection<ValueGroup> valueGroups); void rule(final Builder<RuleBuilder, DecisionTreeRule> ruleBuilderBuilder); void setName(final String name); void setEvaluationNames(final List<String> names); void setCache(final DriverCache cache); void groups(final Set<ValueGroup> groups); List<Builder<RuleBuilder, DecisionTreeRule>> getRuleBuilders(); }
@Test public void testRegExInput() { assertThat(InputBuilder.regExInput(".RegEx"), is("RE:.RegEx")); }
public static String regExInput(final String regex) { return RegexDriver.REGEX_PREFIX + ":" + regex; }
InputBuilder { public static String regExInput(final String regex) { return RegexDriver.REGEX_PREFIX + ":" + regex; } }
InputBuilder { public static String regExInput(final String regex) { return RegexDriver.REGEX_PREFIX + ":" + regex; } private InputBuilder(); }
InputBuilder { public static String regExInput(final String regex) { return RegexDriver.REGEX_PREFIX + ":" + regex; } private InputBuilder(); static String regExInput(final String regex); static String dateRangeInput(final Range<Instant> range); static String integerRangeInput(final Range<Integer> range); }
InputBuilder { public static String regExInput(final String regex) { return RegexDriver.REGEX_PREFIX + ":" + regex; } private InputBuilder(); static String regExInput(final String regex); static String dateRangeInput(final Range<Instant> range); static String integerRangeInput(final Range<Integer> range); }
@Test public void testDateRangeInput() { final String startStr = "2013-03-28T00:00:00Z"; final String endStr = "2015-06-01T10:50:00Z"; final Range<Instant> range = new Range<>(Instant.parse(startStr), Instant.parse(endStr)); assertThat(InputBuilder.dateRangeInput(range), is("DR:" + startStr + "|" + endStr)); }
public static String dateRangeInput(final Range<Instant> range) { return DateRangeDriver.DR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); }
InputBuilder { public static String dateRangeInput(final Range<Instant> range) { return DateRangeDriver.DR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); } }
InputBuilder { public static String dateRangeInput(final Range<Instant> range) { return DateRangeDriver.DR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); } private InputBuilder(); }
InputBuilder { public static String dateRangeInput(final Range<Instant> range) { return DateRangeDriver.DR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); } private InputBuilder(); static String regExInput(final String regex); static String dateRangeInput(final Range<Instant> range); static String integerRangeInput(final Range<Integer> range); }
InputBuilder { public static String dateRangeInput(final Range<Instant> range) { return DateRangeDriver.DR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); } private InputBuilder(); static String regExInput(final String regex); static String dateRangeInput(final Range<Instant> range); static String integerRangeInput(final Range<Integer> range); }
@Test public void testIntegerRangeInput() { assertThat(InputBuilder.integerRangeInput(new Range<>(100, 500)), is("IR:100|500")); }
public static String integerRangeInput(final Range<Integer> range) { return IntegerRangeDriver.IR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); }
InputBuilder { public static String integerRangeInput(final Range<Integer> range) { return IntegerRangeDriver.IR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); } }
InputBuilder { public static String integerRangeInput(final Range<Integer> range) { return IntegerRangeDriver.IR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); } private InputBuilder(); }
InputBuilder { public static String integerRangeInput(final Range<Integer> range) { return IntegerRangeDriver.IR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); } private InputBuilder(); static String regExInput(final String regex); static String dateRangeInput(final Range<Instant> range); static String integerRangeInput(final Range<Integer> range); }
InputBuilder { public static String integerRangeInput(final Range<Integer> range) { return IntegerRangeDriver.IR_PREFIX + ":" + range.getStart() + "|" + range.getFinish(); } private InputBuilder(); static String regExInput(final String regex); static String dateRangeInput(final Range<Instant> range); static String integerRangeInput(final Range<Integer> range); }
@Test public void addValueGroupChange() { testConstruction(); final Instant start = NOW.minus(Period.ofWeeks(-1)); final Instant end = start.plus(Period.ofWeeks(5)); final DateRange range = new DateRange(start, end); final List<String> drivers = Arrays.asList("Test5", "Test6", "Test7"); final ValueGroup valueGroup = new ValueGroup(ADDED_ID, "TestValueGroup", drivers, range); final ValueGroupChange valueGroupChange = new ValueGroupChange(Type.NEW, valueGroup); final ValueGroup originalValueGroupChanged = new ValueGroup(BASE_ID, "TestValueGroup", Arrays.asList("Test2", "Test3"), range); final ValueGroupChange originalValueGroupChange = new ValueGroupChange(Type.NEW, originalValueGroupChanged); getBean().addValueGroupChange(valueGroupChange); getBean().addValueGroupChange(originalValueGroupChange); assertThat(getBean().getValueGroupChanges(), hasSize(3)); assertThat(getBean().getValueGroupChanges(), hasItems(getBean().getValueGroupChanges().iterator().next(), valueGroupChange, originalValueGroupChange)); assertThat(getBean().getRuleChanges(), hasSize(1)); final Map<UUID, Optional<TreeValueGroup>> groups = getBean().getGroups(); assertNotNull(groups); assertThat(groups.size(), is(2)); assertThat(groups, allOf( hasEntry(BASE_ID, Optional.<TreeValueGroup>of(originalValueGroupChanged)), hasEntry(ADDED_ID, Optional.<TreeValueGroup>of(valueGroup)))); }
public boolean addValueGroupChange(final ValueGroupChange change) { EhSupport.ensureArg(change != null, "Cannot add a null value group change"); return this.valueGroupChanges.add(change); }
Change implements TreeChange { public boolean addValueGroupChange(final ValueGroupChange change) { EhSupport.ensureArg(change != null, "Cannot add a null value group change"); return this.valueGroupChanges.add(change); } }
Change implements TreeChange { public boolean addValueGroupChange(final ValueGroupChange change) { EhSupport.ensureArg(change != null, "Cannot add a null value group change"); return this.valueGroupChanges.add(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); }
Change implements TreeChange { public boolean addValueGroupChange(final ValueGroupChange change) { EhSupport.ensureArg(change != null, "Cannot add a null value group change"); return this.valueGroupChanges.add(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
Change implements TreeChange { public boolean addValueGroupChange(final ValueGroupChange change) { EhSupport.ensureArg(change != null, "Cannot add a null value group change"); return this.valueGroupChanges.add(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void testBasicConstruction() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("test1", "test2"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 2L); ruleBuilder.with(RuleBuilder::setId, new UUID(0, 1)); ruleBuilder.with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result")); final DecisionTreeRule rule = ruleBuilder.build(); assertNotNull(rule); final InputDriver[] derivedInputDrivers = rule.getDrivers(); assertEquals("test1", derivedInputDrivers[0].getValue()); assertEquals(InputValueType.STRING, derivedInputDrivers[0].getType()); assertEquals("test2", derivedInputDrivers[1].getValue()); assertEquals(InputValueType.STRING, derivedInputDrivers[1].getType()); assertEquals(new UUID(0, 1), rule.getRuleIdentifier()); assertFalse(rule.getEvaluations().isPresent()); assertEquals("result", rule.getOutputs().get("outputDriver")); assertEquals(DecisionTreeRule.EPOCH, rule.getStart()); assertEquals(DecisionTreeRule.MAX, rule.getEnd()); }
public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
@Test public void testBasicConstructionWithTokenedOutput() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("test1", "test2"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 2L); ruleBuilder.with(RuleBuilder::setId, new UUID(0, 3)); ruleBuilder.with(RuleBuilder::output, Collections.singletonList("outputDriver:result")); final DecisionTreeRule rule = ruleBuilder.build(); assertNotNull(rule); final InputDriver[] derivedInputDrivers = rule.getDrivers(); assertEquals("test1", derivedInputDrivers[0].getValue()); assertEquals(InputValueType.STRING, derivedInputDrivers[0].getType()); assertEquals("test2", derivedInputDrivers[1].getValue()); assertEquals(InputValueType.STRING, derivedInputDrivers[1].getType()); assertEquals(new UUID(0, 3), rule.getRuleIdentifier()); assertFalse(rule.getEvaluations().isPresent()); assertEquals("result", rule.getOutputs().get("outputDriver")); assertEquals(DecisionTreeRule.EPOCH, rule.getStart()); assertEquals(DecisionTreeRule.MAX, rule.getEnd()); }
public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
@Test public void testBasicConstructionWithRegexTypes() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("te.?t1", "test2.*"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 2L); ruleBuilder.with(RuleBuilder::setId, new UUID(0, 1)); ruleBuilder.with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result")); final DecisionTreeRule rule = ruleBuilder.build(); assertNotNull(rule); final InputDriver[] derivedInputDrivers = rule.getDrivers(); assertEquals("te.?t1", derivedInputDrivers[0].getValue()); assertEquals(InputValueType.REGEX, derivedInputDrivers[0].getType()); assertEquals("test2.*", derivedInputDrivers[1].getValue()); assertEquals(InputValueType.REGEX, derivedInputDrivers[1].getType()); assertFalse(rule.getEvaluations().isPresent()); assertEquals(new UUID(0, 1), rule.getRuleIdentifier()); assertEquals("result", rule.getOutputs().get("outputDriver")); assertEquals(DecisionTreeRule.EPOCH, rule.getStart()); assertEquals(DecisionTreeRule.MAX, rule.getEnd()); }
public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
@Test public void testBasicConstructionForValueGroups() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("VG:VG1:test1:test2:test3:test4", "VG:VG2:test10:test20:test30:test40:VG:VG3:test50:test9.?:test200.*"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 2L); ruleBuilder.with(RuleBuilder::setId, new UUID(0, 1)); ruleBuilder.with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result")); final DecisionTreeRule rule = ruleBuilder.build(); assertNotNull(rule); final InputDriver[] derivedInputDrivers = rule.getDrivers(); assertEquals("VG1", derivedInputDrivers[0].getValue()); assertEquals(InputValueType.VALUE_GROUP, derivedInputDrivers[0].getType()); assertEquals("VG2", derivedInputDrivers[1].getValue()); assertEquals(InputValueType.VALUE_GROUP, derivedInputDrivers[1].getType()); assertEquals(new UUID(0, 1), rule.getRuleIdentifier()); assertEquals("result", rule.getOutputs().get("outputDriver")); assertFalse(rule.getEvaluations().isPresent()); assertEquals(DecisionTreeRule.EPOCH, rule.getStart()); assertEquals(DecisionTreeRule.MAX, rule.getEnd()); }
public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
@Test public void testDatedRuleConstruction() { final Instant startTime = Instant.now().minus(1, ChronoUnit.DAYS); final Instant endTime = Instant.now().plus(1, ChronoUnit.DAYS); final DecisionTreeRule rule = RuleBuilder.creator().with(RuleBuilder::input, Arrays.asList("test1", "test2")) .with(RuleBuilder::setDriverCount, 2L) .with(RuleBuilder::setId, new UUID(0, 1)) .with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result")) .with(RuleBuilder::start, startTime) .with(RuleBuilder::end, endTime) .build(); assertNotNull(rule); }
public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
@Test public void testConstructionWithEvaluations() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("test1", "test2"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 2L); ruleBuilder.with(RuleBuilder::evaluations, Arrays.asList("Eval1", "Eval2")); ruleBuilder.with(RuleBuilder::setId, new UUID(0, 1)); ruleBuilder.with(RuleBuilder::output, Collections.singletonMap("outputDriver", "result")); final DecisionTreeRule rule = ruleBuilder.build(); assertNotNull(rule); assertTrue(rule.getEvaluations().isPresent()); final InputDriver[] derivedEvaluations = rule.getEvaluations().get(); assertEquals("Eval1", derivedEvaluations[0].getValue()); assertEquals(InputValueType.STRING, derivedEvaluations[0].getType()); assertEquals("Eval2", derivedEvaluations[1].getValue()); assertEquals(InputValueType.STRING, derivedEvaluations[1].getType()); assertEquals(new UUID(0, 1), rule.getRuleIdentifier()); assertEquals("result", rule.getOutputs().get("outputDriver")); assertEquals(DecisionTreeRule.EPOCH, rule.getStart()); assertEquals(DecisionTreeRule.MAX, rule.getEnd()); }
public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
@Test(expected = IllegalArgumentException.class) public void testIncorrectNumberOfDrivers() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); final List<String> testInputs = Arrays.asList("test1", "test2"); ruleBuilder.with(RuleBuilder::input, testInputs); ruleBuilder.with(RuleBuilder::setDriverCount, 1L); ruleBuilder.build(); }
public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
@Test public void testInvalidRuleConstructionIfEmptyInputs() { final Builder<RuleBuilder, DecisionTreeRule> ruleBuilder = RuleBuilder.creator(); assertNotNull(ruleBuilder); assertNull(ruleBuilder.build()); }
public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
RuleBuilder { public static Builder<RuleBuilder, DecisionTreeRule> creator() { return Builder.instanceOf(RuleBuilder.create(), RuleBuilder.validate(), RuleBuilder::builds); } static Builder<RuleBuilder, DecisionTreeRule> creator(); static DecisionTreeRule builds(final RuleBuilder builder); void setId(final UUID id); void setAlternativeId(final Long alternativeId); void setCode(final UUID uuid); void setDriverCount(final Long driverCount); RuleBuilder input(final List<String> drivers); RuleBuilder evaluations(final List<String> evaluations); RuleBuilder cache(final DriverCache cache); RuleBuilder output(final Map<String, String> outputs); RuleBuilder output(final List<String> outputs); void start(final Instant startTime); void end(final Instant endTime); }
@Test public void convertStringToDateRangeDriverAndTestDates() { final DriverCache cache = new DriverCache(); final String testString = "DR:2017-07-04T16:00:00.000Z|2017-07-10T16:00:00.000Z"; final Supplier<InputDriver> rangeSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver dateRangeDriver = rangeSupplier.get(); assertNotNull(dateRangeDriver); assertThat(dateRangeDriver.getType(), is(InputValueType.DATE_RANGE)); assertThat(dateRangeDriver.getValue(), is(testString)); assertThat(dateRangeDriver.evaluate("2017-07-04T16:00:00.000Z"), is(true)); assertThat(dateRangeDriver.evaluate("2017-07-10T16:00:00.000Z"), is(false)); }
public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
@Test public void convertStringToIntegerRangeAndTestData() { final DriverCache cache = new DriverCache(); final String testString = "IR:100|12345"; final Supplier<InputDriver> rangeSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver intRangeDriver = rangeSupplier.get(); assertNotNull(intRangeDriver); assertThat(intRangeDriver.getType(), is(InputValueType.INTEGER_RANGE)); assertThat(intRangeDriver.getValue(), is(testString)); assertThat(intRangeDriver.evaluate("123"), is(true)); assertThat(intRangeDriver.evaluate("54321"), is(false)); }
public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
@Test(expected = IllegalArgumentException.class) public void cannotAddNullValueGroupChange() { testConstruction(); getBean().addValueGroupChange(null); }
public boolean addValueGroupChange(final ValueGroupChange change) { EhSupport.ensureArg(change != null, "Cannot add a null value group change"); return this.valueGroupChanges.add(change); }
Change implements TreeChange { public boolean addValueGroupChange(final ValueGroupChange change) { EhSupport.ensureArg(change != null, "Cannot add a null value group change"); return this.valueGroupChanges.add(change); } }
Change implements TreeChange { public boolean addValueGroupChange(final ValueGroupChange change) { EhSupport.ensureArg(change != null, "Cannot add a null value group change"); return this.valueGroupChanges.add(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); }
Change implements TreeChange { public boolean addValueGroupChange(final ValueGroupChange change) { EhSupport.ensureArg(change != null, "Cannot add a null value group change"); return this.valueGroupChanges.add(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
Change implements TreeChange { public boolean addValueGroupChange(final ValueGroupChange change) { EhSupport.ensureArg(change != null, "Cannot add a null value group change"); return this.valueGroupChanges.add(change); } Change(final UUID id, final String ruleSetName, final Instant activationTime, final DateRange changeRange, final Audit audit, final Set<RuleChange> ruleChanges, final Set<ValueGroupChange> valueGroupChanges); UUID getId(); String getRuleSetName(); Instant getActivationTime(); DateRange getChangeRange(); Set<RuleChange> getRuleChanges(); @Override Map<UUID, Optional<TreeRule>> getRules(); @Override Map<UUID, Optional<TreeValueGroup>> getGroups(); Set<ValueGroupChange> getValueGroupChanges(); boolean addRuleChange(final RuleChange change); boolean addRuleChange(final Set<RuleChange> changes); boolean removeRuleChange(final RuleChange change); boolean addValueGroupChange(final ValueGroupChange change); boolean removeValueGroupChange(final ValueGroupChange change); Audit getAudit(); void setAudit(final Audit audit); @Override boolean equals(final Object other); @Override int hashCode(); }
@Test public void convertStringToIntegerRangeWithMax() { final DriverCache cache = new DriverCache(); final String testString = "IR:100|"; final Supplier<InputDriver> rangeSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver intRangeDriver = rangeSupplier.get(); assertNotNull(intRangeDriver); assertThat(intRangeDriver.getType(), is(InputValueType.INTEGER_RANGE)); assertThat(intRangeDriver.getValue(), is(testString)); assertThat(intRangeDriver.evaluate("123"), is(true)); final Integer maxInt = new Integer(Integer.MAX_VALUE); assertThat(intRangeDriver.evaluate(maxInt.toString()), is(false)); final Integer almostMaxInt = new Integer(Integer.MAX_VALUE - 1); assertThat(intRangeDriver.evaluate(almostMaxInt.toString()), is(true)); }
public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
@Test public void convertStringToIntegerRangeWithMin() { final DriverCache cache = new DriverCache(); final String testString = "IR:|100"; final Supplier<InputDriver> rangeSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver intRangeDriver = rangeSupplier.get(); assertNotNull(intRangeDriver); assertThat(intRangeDriver.getType(), is(InputValueType.INTEGER_RANGE)); assertThat(intRangeDriver.getValue(), is(testString)); assertThat(intRangeDriver.evaluate("12"), is(true)); final Integer minInt = new Integer(Integer.MIN_VALUE); assertThat(intRangeDriver.evaluate(minInt.toString()), is(true)); }
public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
@Test(expected = IllegalStateException.class) public void convertStringToIntegerRangeWithMissingDeliminator() { final DriverCache cache = new DriverCache(); final String testString = "IR:1223"; final Supplier<InputDriver> rangeSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver intRangeDriver = rangeSupplier.get(); }
public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
@Test (expected = IllegalStateException.class) public void failInvalidStringToDateRangeDriver() { DomainSerialiser.createInputDriver("DR:2017-07-04T16:00:00.000Z2017-07-10T16:00:00.000Z", new DriverCache()).get(); }
public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
@Test (expected = DateTimeParseException.class) public void failInvalidDateStringToDateRangeDriver() { DomainSerialiser.createInputDriver("DR:2017-04T16:00:00.000Z|2017-07-10T16:00:00.000Z", new DriverCache()).get(); }
public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
@Test public void convertBrokenEmptyStrings() { final DriverCache cache = new DriverCache(); final String testString = "VG:1::"; final Supplier<InputDriver> groupSupplier = DomainSerialiser.createInputDriver(testString, cache); final InputDriver groupDriver = groupSupplier.get(); assertNotNull(groupDriver); final InputDriver[] drivers = ((GroupDriver) groupDriver).getSubDrivers(false); assertEquals(0, drivers.length); }
public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
@Test public void convertStringToGroupDriverWithSubGroups() { final DriverCache cache = new DriverCache(); final Supplier<InputDriver> groupSupplier = DomainSerialiser.createInputDriver("VG:TestGroup:Test", cache); final InputDriver groupDriver = groupSupplier.get(); assertNotNull(groupDriver); assertEquals("TestGroup", groupDriver.getValue()); assertEquals(InputValueType.VALUE_GROUP, groupDriver.getType()); assertEquals(groupDriver, cache.get("TestGroup", InputValueType.VALUE_GROUP)); }
public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }
DomainSerialiser { public static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache) { return () -> { final InputValueType type = INPUT_VALUE_TYPE_FUNCTION.apply(currentDriver); final InputDriver inputDriver; if (InputValueType.VALUE_GROUP.equals(type)) { inputDriver = getValueGroupDriver(currentDriver, cache, type); } else { inputDriver = getSingleDriver(currentDriver, cache, type); } return inputDriver; }; } private DomainSerialiser(); static List<String> convertDrivers(final InputDriver[] drivers); static List<String> convertDriversWithSubGroups(final List<InputDriver> drivers); static List<String> convertOutputs(final Map<String, String> outputMap); static Map<String, String> convertOutputs(final List<String> outputs); static Supplier<InputDriver> createInputDriver(final String currentDriver, final DriverCache cache); }