@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public <V> RemovalHandler registerParser(final Class<V> classLit, final ConvertsValue<V,String> serializer, final ConvertsValue<String,V> deserializer ) { final ConvertsValue<?,String> currentSerializer = serializers.put(classLit, serializer); final ConvertsValue<String,?> currentDeserialize = deserializers.put(classLit, deserializer); // In case a user wants to wrap the existing serializers, we will send them the previous instances. if (serializer instanceof ReceivesValue) { ((ReceivesValue)serializer).set(currentSerializer); } if (deserializer instanceof ReceivesValue) { ((ReceivesValue)deserializer).set(currentDeserialize); } return new RemovalHandler() { @Override public void remove() { // check before set. if (serializers.get(classLit) == serializer) { serializers.put(classLit, currentSerializer); } if (deserializers.get(classLit) == deserializer) { deserializers.put(classLit, currentDeserialize); } } }; }
@Override @SuppressWarnings("unchecked") // The class key is always checked for us... public <V> IORequestBuilder<V> request(final Class<V> classLit, final String id) { return this.<V>createRequestBuilder() .setUrl(toUrl(classLit, id)) .setDeserializer(ConvertsValue.class.cast(deserializers.get(classLit))) .setSerializer(ConvertsValue.class.cast(serializers.get(classLit))) ; }
@Override public String register(final Class<? extends Model> model) { final String typeName = getTypeName(model); classToTypeName.put(model, typeName); typeNameToClass.put(typeName, model); final ModelSerializer serializer = getSerializer(typeName); serializers.put(typeName, serializer); return typeName; }
/** * @see xapi.model.impl.AbstractModelService#create(java.lang.Class) */ @SuppressWarnings({ "unchecked", "rawtypes" }) @Override public <M extends Model> M create(final Class<M> key) { ProvidesValue factory = modelFactories.get(key); if (factory == null) { factory = createModelFactory(key); modelFactories.put(key, factory); } return (M)factory.get(); }
@Override @MagicMethod(doNotVisit=true, documentation="This magic method re-routes to the same provider as X_Inject.instance()") public <T extends Model> T create(final Class<T> key) { // GWT dev will make it here, and it can handle non-class-literal injection. // GWT prod requires magic method injection here. final T instance = X_Inject.instance(key); if (instance == null) { return null; } typeNameToClass.put(instance.getType(), key); classToTypeName.put(key, instance.getType()); return instance; }
protected ModelManifest getOrMakeModelManifest(final Class<? extends Model> cls) { final ModelModule module = currentModule.get(); if (module != null) { final String typeName = getTypeName(cls); return module.getManifest(typeName); } ModelManifest manifest = modelManifests.get(cls); if (manifest == null) { manifest = ModelUtil.createManifest(cls); modelManifests.put(cls, manifest); } return manifest; }
protected String getTypeName(final Class<? extends Model> cls) { String known = classToTypeName.get(cls); if (known != null) { return known; } if (!cls.isInterface()) { // For non-interfaces, lets look for the most specfic Model interface Class<?> winner = cls; for (final Class<?> iface : cls.getInterfaces()) { if (Model.class.isAssignableFrom(iface)) { if (winner == cls || winner.isAssignableFrom(iface)) { winner = iface; } } } if (winner != cls) { known = classToTypeName.get(winner); if (known != null) { classToTypeName.put(cls, known); typeNameToClass.put(known, cls); return known; } } } final String name = ModelUtil.guessModelType(cls); classToTypeName.put(cls, name); typeNameToClass.put(name, cls); return name; }