Status: New
Owner: ----
Labels: Type-Defect Priority-Medium
New issue 200 by
rx303...@gmail.com: Reduce code bloat for multiple
instances of the same PrivateGinModule
https://code.google.com/p/google-gin/issues/detail?id=200
What steps will reproduce the problem?
1. Create a hierarchy of classes which you need to bind to the same
interface with different parameterizing type:
public interface MyInterface<T>
{
void doSomething();
}
public class MyInterfaceImpl<T> implements MyInterface<T>
{
//External services (usually singletons), defined in a global GinModule
@Inject
Service1 service1;
@Inject
Service2 service2;
//some base logic
}
public class MyInterfaceStringImpl extends MyInterfaceImpl<String>
{
//some logic for String implementation
}
public class MyInterfaceIntegerImpl extends MyInterfaceImpl<Integer>
{
//some logic for Integer implementation
}
public class MyInterfaceDoubleImpl extends MyInterfaceImpl<Double>
{
//some logic for Double implementation
}
2. Make PrivateGinModule which exposes interface with different
parameterizing type:
public class MyPrivateGinModule<T> extends PrivateGinModule
{
private final Class<T> param;
private Class<? extends MyInterface<T>> implementation;
public MyPrivateGinModule(Class<T> param)
{
this.param=param;
}
public MyPrivateGinModule<T> setImplementation(Class<? extends
MyInterface<T>> implementation)
{
this.implementation=implementation;
return this;
}
protected void configure()
{
...
bind(typeLiteral(MyInterface.class, param)).to(implementation);
expose(typeLiteral(MyInterface.class, param));
//typeLiteral is utility method which makes
TypeLiteral<MyInterface<T>> during rebind phase using
Types.newParameterizedType() and TypeLiteral.get()
}
}
3. Install several instances of that module:
public class MyGlobalGinModule extends AbstractGinModule
{
protected void configure()
{
install(new
MyPrivateGinModule<Integer>(Integer.class).setImplementation(MyInterfaceIntegerImpl.class));//
now we can @Inject MyInterface<Integer>
install(new
MyPrivateGinModule<String>(String.class).setImplementation(MyInterfaceStringImpl.class));//
now we can @Inject MyInterface<String>
install(new
MyPrivateGinModule<Double>(Double.class).setImplementation(MyInterfaceDoubleImpl.class));//
now we can @Inject MyInterface<Double>
}
}
4. Compile the code.
What is the expected output? What do you see instead?
Each installed instance of MyPrivateGinModule generates fragments for
dependencies defined inside - that's OK.
But also it generates fragments for all external dependencies (Service1 and
Service2) which do not differ from one MyPrivateGinModule instance bindings
to another.
That causes a lot of duplication in generated code and increases total size
of compiled js-code.
--
You received this message because this project is configured to send all
issue notifications to this address.
You may adjust your notification preferences at:
https://code.google.com/hosting/settings