@Override public <T> MessagePackAdapter<T> adapterFor( final ValueType valueType ) { return castAdapter( adapters.keySet().stream() .collect( closestType( valueType ) ) .map( adapters::get ) .orElse( null ) ); }
public static <T extends HasTypes> Collector<T, ?, Optional<T>> matchingType( T hasTypes ) { return hasTypesFindFirstCollector( hasTypes, new HasAssignableFromType<>( hasTypes ) ); }
public static <T extends HasTypes> Collector<T, ?, List<T>> closestTypes( T hasTypes ) { return hasTypesToListCollector( hasTypes, new HasAssignableToType<>( hasTypes ) ); }
@Override public List<? extends ModelDescriptor> lookupServiceModels( final Type type ) { return servicesReferences.computeIfAbsent( type, key -> allServices().collect( HasTypesCollectors.matchingTypes( key ) ) ); }
/** * Collect a single matching HasTypes. * * TODO Detail * * @param type type to match * @param <T> type of HasTypes * @return an optional best matching HasTypes */ public static <T extends HasTypes> Collector<T, ?, Optional<T>> matchingType( Type type ) { return typeFindFirstCollector( type, new HasAssignableFromType<>( type ) ); }
public static <T extends HasTypes> Collector<T, ?, List<T>> closestTypes( Type type ) { return typeToListCollector( type, new HasAssignableToType<>( type ) ); }
@Override public ModelDescriptor lookupServiceModel( Type serviceType ) { return serviceModels.computeIfAbsent( serviceType, key -> allServices().collect( HasTypesCollectors.matchingType( key ) ).orElse( null ) ); }
@Override public List<EntityDescriptor> lookupEntityModels( final Class type ) { return entityModels.computeIfAbsent( type, key -> allEntities().collect( HasTypesCollectors.matchingTypes( key ) ) ); }
public static <T extends HasTypes> Collector<T, ?, Optional<T>> closestType( Type type ) { return typeFindFirstCollector( type, new HasAssignableToType<T>( type ) ); }
public static <T extends HasTypes> Collector<T, ?, List<T>> closestTypes( Type type ) { return typeToListCollector( type, new HasAssignableToType<>( type ) ); }
@Test public void selectMatchingType() { List<ValueType> valueTypes = Arrays.asList( ValueType.of( String.class ), ValueType.of( Double.class ), ValueType.of( Integer.class ) ); Optional<ValueType> number = valueTypes.stream() .collect( HasTypesCollectors.matchingType( Number.class ) ); assertTrue( number.isPresent() ); assertThat( number.get(), equalTo( ValueType.of( Double.class ) ) ); Optional<ValueType> integer = valueTypes.stream() .collect( HasTypesCollectors.matchingType( Integer.class ) ); assertTrue( integer.isPresent() ); assertThat( integer.get(), equalTo( ValueType.of( Integer.class ) ) ); }
@Override public <T> JavaxXmlAdapter<T> adapterFor( final ValueType valueType ) { return castAdapter( adapters.keySet().stream() .collect( closestType( valueType ) ) .map( adapters::get ) .orElse( null ) ); }
@Test public void selectMatchingTypes() { List<ValueType> valueTypes = Arrays.asList( ValueType.of( String.class ), ValueType.of( Integer.class ), ValueType.of( Number.class ) ); List<ValueType> number = valueTypes.stream().collect( HasTypesCollectors.matchingTypes( Number.class ) ); assertThat( number.size(), is( 2 ) ); assertThat( number.get( 0 ), equalTo( ValueType.of( Number.class ) ) ); assertThat( number.get( 1 ), equalTo( ValueType.of( Integer.class ) ) ); List<ValueType> integer = valueTypes.stream().collect( HasTypesCollectors.matchingTypes( Integer.class ) ); assertThat( integer.size(), is( 1 ) ); assertThat( integer.get( 0 ), equalTo( ValueType.of( Integer.class ) ) ); }
/** * Collect a single matching HasTypes. * * TODO Detail * * @param type type to match * @param <T> type of HasTypes * @return an optional best matching HasTypes */ public static <T extends HasTypes> Collector<T, ?, Optional<T>> matchingType( Type type ) { return typeFindFirstCollector( type, new HasAssignableFromType<>( type ) ); }
public static <T extends HasTypes> Collector<T, ?, List<T>> matchingTypes( T hasTypes ) { return hasTypesToListCollector( hasTypes, new HasAssignableFromType<>( hasTypes ) ); }
public static <T extends HasTypes> Collector<T, ?, Optional<T>> closestType( T hasTypes ) { return hasTypesFindFirstCollector( hasTypes, new HasAssignableToType<>( hasTypes ) ); }
/** * Collect all matching HasTypes. * * First the ones with at least on equal type. * Then the ones with at least one type assignable from {@literal type}. * * @param type type to match * @param <T> type of HasTypes * @return an optional best matching HasTypes */ public static <T extends HasTypes> Collector<T, ?, List<T>> matchingTypes( Type type ) { return typeToListCollector( type, new HasAssignableFromType<>( type ) ); }
@Test public void selectMatchingValueType() { List<ValueType> valueTypes = Arrays.asList( ValueType.of( String.class ), ValueType.of( Number.class, Integer.class ), ValueType.of( Integer.class ), ValueType.of( Number.class ) ); Optional<ValueType> number = valueTypes.stream() .collect( HasTypesCollectors.matchingType( ValueType.of( Number.class ) ) ); assertTrue( number.isPresent() ); assertThat( number.get(), equalTo( ValueType.of( Number.class ) ) ); Optional<ValueType> integer = valueTypes.stream() .collect( HasTypesCollectors.matchingType( ValueType.of( Integer.class ) ) ); assertTrue( integer.isPresent() ); assertThat( integer.get(), equalTo( ValueType.of( Integer.class ) ) ); Optional<ValueType> both = valueTypes.stream() .collect( HasTypesCollectors.matchingType( ValueType.of( Number.class, Integer.class ) ) ); assertTrue( both.isPresent() ); assertThat( both.get(), equalTo( ValueType.of( Number.class, Integer.class ) ) ); }
@Override public <T> JavaxJsonAdapter<T> adapterFor( ValueType valueType ) { if( resolvedAdaptersCache.containsKey( valueType ) ) { return castAdapter( resolvedAdaptersCache.get( valueType ) ); } JavaxJsonAdapter<T> adapter = castAdapter( adapters.keySet().stream() .collect( closestType( valueType ) ) .map( adapters::get ) .orElse( null ) ); resolvedAdaptersCache.put( valueType, adapter ); return adapter; }
@Test public void selectMatchingValueTypes() { List<ValueType> valueTypes = Arrays.asList( ValueType.of( String.class ), ValueType.of( Number.class, Integer.class ), ValueType.of( Integer.class ), ValueType.of( Number.class ) ); List<ValueType> number = valueTypes.stream() .collect( HasTypesCollectors.matchingTypes( ValueType.of( Number.class ) ) ); System.out.println( number ); assertThat( number.size(), is( 2 ) ); assertThat( number.get( 0 ), equalTo( ValueType.of( Number.class ) ) ); assertThat( number.get( 1 ), equalTo( ValueType.of( Number.class, Integer.class ) ) ); List<ValueType> integer = valueTypes.stream() .collect( HasTypesCollectors.matchingTypes( ValueType.of( Integer.class ) ) ); assertThat( integer.size(), is( 2 ) ); assertThat( integer.get( 0 ), equalTo( ValueType.of( Integer.class ) ) ); assertThat( integer.get( 1 ), equalTo( ValueType.of( Number.class, Integer.class ) ) ); List<ValueType> both = valueTypes.stream() .collect( HasTypesCollectors.matchingTypes( ValueType.of( Number.class, Integer.class ) ) ); assertThat( both.size(), is( 1 ) ); assertThat( both.get( 0 ), equalTo( ValueType.of( Number.class, Integer.class ) ) ); }