public synchronized <Model, Data> ModelLoader<Model, Data> build(@NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass) { return multiModelLoaderFactory.build(modelClass, dataClass); }
public ModelLoaderRegistry(@NonNull Pool<List<Throwable>> throwableListPool) { this(new MultiModelLoaderFactory(throwableListPool)); }
@NonNull synchronized <Model, Data> List<ModelLoaderFactory<? extends Model, ? extends Data>> replace( @NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass, @NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) { List<ModelLoaderFactory<? extends Model, ? extends Data>> removed = remove(modelClass, dataClass); append(modelClass, dataClass, factory); return removed; }
loaders.add(this.<Model, Data>build(entry)); alreadyUsedEntries.remove(entry); return emptyModelLoader(); } else { throw new NoModelLoaderAvailableException(modelClass, dataClass);
@Test public void testRemove_removesPreviouslyRegisteredFactories_withModelAndDataClasses() { appendFactoryFor(String.class, String.class); appendFactoryFor(String.class, String.class); multiFactory.remove(String.class, String.class); List<ModelLoader<String, ?>> modelLoaders = multiFactory.build(String.class); assertThat(modelLoaders).isEmpty(); }
private <X, Y> ModelLoader<X, Y> registerFactoryFor( Class<X> modelClass, Class<Y> dataClass, boolean append) { ModelLoaderFactory<X, Y> factory = mockFactory(); @SuppressWarnings("unchecked") ModelLoader<X, Y> loader = mock(ModelLoader.class); when(factory.build(eq(multiFactory))).thenReturn(loader); if (append) { multiFactory.append(modelClass, dataClass, factory); } else { multiFactory.prepend(modelClass, dataClass, factory); } return loader; }
@Test public void testReplace_returnsPreviouslyRegisteredFactories_withModelAndDataClasses() { ModelLoaderFactory<String, String> firstOtherFactory = mockFactory(); ModelLoaderFactory<String, String> secondOtherFactory = mockFactory(); multiFactory.append(String.class, String.class, firstOtherFactory); multiFactory.append(String.class, String.class, secondOtherFactory); List<ModelLoaderFactory<? extends String, ? extends String>> removed = multiFactory.replace(String.class, String.class, firstFactory); assertThat(removed).containsExactly(firstOtherFactory, secondOtherFactory); }
public synchronized <Model, Data> void append( @NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass, @NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) { multiModelLoaderFactory.append(modelClass, dataClass, factory); cache.clear(); }
public synchronized <Model, Data> void remove(@NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass) { tearDown(multiModelLoaderFactory.remove(modelClass, dataClass)); cache.clear(); }
public synchronized <Model, Data> void replace( @NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass, @NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) { tearDown(multiModelLoaderFactory.replace(modelClass, dataClass, factory)); cache.clear(); }
public synchronized <Model, Data> void prepend( @NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass, @NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) { multiModelLoaderFactory.prepend(modelClass, dataClass, factory); cache.clear(); }
synchronized <Model, Data> void prepend( @NonNull Class<Model> modelClass, @NonNull Class<Data> dataClass, @NonNull ModelLoaderFactory<? extends Model, ? extends Data> factory) { add(modelClass, dataClass, factory, /*append=*/ false); }
loaders.add(this.<Model, Data>build(entry)); alreadyUsedEntries.remove(entry); return emptyModelLoader(); } else { throw new NoModelLoaderAvailableException(modelClass, dataClass);
@Test public void testBuild_withModelAndDataClasses_excludesModelLoadersForOtherDataClasses() { multiFactory.append(String.class, String.class, firstFactory); assertThrows( NoModelLoaderAvailableException.class, new ThrowingRunnable() { @Override public void run() throws Throwable { multiFactory.build(String.class, Integer.class); } }); }