@Override @Nonnull public <T> T get(Class<T> type) { return providerMap.get(type).build().get(type); }
@SuppressWarnings("unchecked") <T> boolean doRegister(T object) { boolean success = false; final Set<Class<?>> modelSupportedTypes = registry.keySet(); for (final Class<?> modelSupportedType : modelSupportedTypes) { if (modelSupportedType.isAssignableFrom(object.getClass())) { final Collection<Model<?>> assignableModels = registry .get(modelSupportedType); for (final Model<?> m : assignableModels) { success |= ((Model<T>) m).register(object); } } } return success; }
/** * Unregisters the given object. * @param object The object to unregister. * @param <T> The type of object. * @throws IllegalArgumentException if an instance of {@link Model} is * provided or if the model could not be unregistered from any * model. */ @SuppressWarnings("unchecked") public <T> void unregister(T object) { checkArgument(!(object instanceof Model), "can not unregister a model"); boolean result = false; final Set<Class<?>> modelSupportedTypes = registry.keySet(); for (final Class<?> modelSupportedType : modelSupportedTypes) { // check if object is from a known type if (modelSupportedType.isAssignableFrom(object.getClass())) { final Collection<Model<?>> assignableModels = registry .get(modelSupportedType); for (final Model<?> m : assignableModels) { result |= ((Model<T>) m).unregister(object); } } } checkArgument(result, "Object %s with type %s can not be unregistered.", object, object.getClass()); }
@SuppressWarnings("unchecked") ModelManager(ImmutableSet<? extends Model<?>> ms) { models = (ImmutableSet<Model<?>>) ms; final ImmutableSetMultimap.Builder<Class<?>, Model<?>> builder = ImmutableSetMultimap .builder(); builder.put(ModelReceiver.class, new ModelReceiverModel(this)); final Set<UserInterface> uis = new LinkedHashSet<>(); for (final Model<?> m : models) { final Class<?> suptype = m.getSupportedType(); checkNotNull(suptype, "Model.getSupportedType() must return a non-null, model: %s.", m); builder.put(suptype, m); if (m instanceof UserInterface) { uis.add((UserInterface) m); } } checkState(uis.size() <= 1, "At most one implementor of %s can be defined, found %s.", UserInterface.class, uis); if (uis.isEmpty()) { userInterface = Optional.absent(); } else { userInterface = Optional.of(uis.iterator().next()); } registry = builder.build(); for (final Model<?> m : models) { doRegister(m); } }
@Override public <T> T get(Class<T> type) { assertThat(classMap.containsKey(type) || map.containsKey(type)).isTrue(); if (classMap.containsKey(type)) { return classMap.getInstance(type); } return map.get(type).get(type); }