This code is pretty rough. Try sending your emails as RTF or setting
your right margin to something like 150 or 200.
-bp
On Jan 22, 2009, at 12:03 PM, Alen Vrečko wrote:
>
> Hi,
>
> correct me if I am wrong guys,
>
> The point is here
>
> static class Leg {
> @Inject Foot foot;
>
> Notice you're injecting a Foot but how do you know which Foot?
>
> You can't to
>
> static class Leg {
> @Inject @Left @Right Foot foot;
>
> that makes no sense
>
> static class Robot {
> @Inject @Left Leg leftLeg;
> @Inject @Right Leg rightLeg;
>
> Now you can't do
>
> bind(Foot.class).to(new Foot("Lefty")).ifParentAnnotatedWith
> (Left.class);
> bind(Foot.class).to(new Foot("Righty")).ifParentAnnotatedWith
> (Right.class);
>
> but notice how with Private Module you can get this functionality.
>
> I've been playing around with this and made an example using a Car
> maybe that will be clearer. I get confused with Feet and Leg on first
> reading.
>
> Cheers,
> Alen
>
> /////////////////////////////////////////////////////////////////////////////////
> import com.google.inject.*;
> import com.google.inject.privatemodules.PrivateModule;
>
> import static java.lang.annotation.ElementType.*;
> import java.lang.annotation.Retention;
> import java.lang.annotation.RetentionPolicy;
> import java.lang.annotation.Target;
> import java.util.Date;
>
> public class RobotLegsProblem2 {
>
>
> public static void main(String[] args) {
> Injector injector = Guice.createInjector(new AbstractModule()
> {
> @Override
> protected void configure() {
> // global stuff
> // same to all
> bind(Driveline.class).to(FrontWheelDrive.class);
> bind(Engine.class).to(DieselEngine.class);
> }
> }, new PrivateModule() {
> @Override
> protected void configurePrivateBindings() {
> // private Module is different story
> // Bind car annotated with blue and expose it
> bind(Car.class).annotatedWith(Blue.class).to
> (Car.class);
> expose(Car.class).annotatedWith(Blue.class);
>
> // What we bind in here only applies to the exposed
> stuff
> // i.e. the exposed car from this module will get this
> injected
> // where stuff in regular module (Engine,Driveline) is
> "inherited" - it is global
> bind(Transmission.class).to
> (AutomaticTransmission.class);
> }
> }, new PrivateModule() {
> @Override
> protected void configurePrivateBindings() {
> bind(Car.class).annotatedWith(Red.class).to
> (Car.class);
> expose(Car.class).annotatedWith(Red.class);
>
> bind(Transmission.class).to(ManualTransmission.class);
> // The point is that you cannot do this with regular
> module i.e.
> // bind(Car.class).annotatedWith(Blue.class).to
> (Car.class);
> // bind(Car.class).annotatedWith(Red.class).to
> (Car.class);
> // now notice the dilemma
> // class Car{
> // @Inject Transmission transmission;
> // ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
> // You cannot solve this by
> // @Inject @Blue @Red Transmission transmission;
> // or
> // bind(Transmission.class).to
> (AutomaticTransmission.class).ifParentAnnotatedWith(Blue.class)
> // bind(Transmission.class).to
> (ManualTransmission.class).ifParentAnnotatedWith(Red.class)
> // but with private modules you can get this
> functionality
> }
> });
>
> Car blueCar = injector.getInstance(Key.get(Car.class,
> Blue.class));
> System.out.println("Blue car transmission: " +
> blueCar.getTransmission());
>
> Car redCar = injector.getInstance(Key.get(Car.class,
> Red.class));
> System.out.println("Red car transmission: " +
> redCar.getTransmission());
>
> }
>
>
> }
>
> @Retention(RetentionPolicy.RUNTIME)
> @Target({FIELD, PARAMETER, METHOD})
> @BindingAnnotation
> @interface Blue {
> }
>
> @Retention(RetentionPolicy.RUNTIME)
> @Target({FIELD, PARAMETER, METHOD})
> @BindingAnnotation
> @interface Red {
> }
>
> class Car {
>
> private final Engine engine;
> private final Transmission transmission;
> private final Driveline driveline;
>
> @Inject
> public Car(Engine engine, Transmission transmission, Driveline
> driveline) {
> this.engine = engine;
> this.transmission = transmission;
> this.driveline = driveline;;
> }
>
> public Driveline getDriveline() {
> return driveline;
> }
>
> public Engine getEngine() {
> return engine;
> }
>
> public Transmission getTransmission() {
> return transmission;
> }
> }
>
>
> interface Transmission {
> }
>
> class AutomaticTransmission implements Transmission {
> }
>
> class ManualTransmission implements Transmission {
> }
>
> interface Engine {
> }
>
> class DieselEngine implements Engine {
> }
>
> class PetrolEngine implements Engine {
> }
>
> interface Driveline {
> }
>
> class FourWheelDrive implements Driveline {
> }
>
> class FrontWheelDrive implements Driveline {
> }
>
> class RearWheelDrive implements Driveline {
> }
>
>
>
> On Jan 22, 1:45 pm, Anthony MULLER <[email protected]> wrote:
>> Can you explain me what is the case known as "robot legs problem" ?
>>
>> I read FAQ and example here
>> :http://docs.google.com/View?docid=dhfm3hw2_51d2tmv6pc
>>
>> Basically, I don't see why not to write simply this :
>>
>> public class LegModule extends AbstractModule {
>>
>> void configure () {
>> bind(Foot.class).annotatedWith(Left.class).toInstance(new
>> Foot(
>> "leftie"));
>> bind(Foot.class).annotatedWith(Right.class).toInstance(new
>> Foot(
>> "righty"));
>> }
>>
>> }
>>
>> Note : gmail coding...
>>
>> Thanks !
>> Anthony
> >
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups
"google-guice" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to
[email protected]
For more options, visit this group at
http://groups.google.com/group/google-guice?hl=en
-~----------~----~----~----~------~----~------~--~---
