Home | History | Annotate | Download | only in internal 
      1 /**
      2  * Copyright (C) 2009 Google Inc.
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  * http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.google.inject.internal;
     18 
     19 import static com.google.common.base.Preconditions.checkState;
     20 
     21 import com.google.common.collect.ImmutableList;
     22 import com.google.common.collect.ImmutableSet;
     23 import com.google.common.collect.Lists;
     24 import com.google.inject.Key;
     25 import com.google.inject.MembersInjector;
     26 import com.google.inject.Provider;
     27 import com.google.inject.TypeLiteral;
     28 import com.google.inject.matcher.Matcher;
     29 import com.google.inject.matcher.Matchers;
     30 import com.google.inject.spi.InjectionListener;
     31 import com.google.inject.spi.Message;
     32 import com.google.inject.spi.TypeEncounter;
     33 
     34 import java.lang.reflect.Method;
     35 import java.util.List;
     36 
     37 /**
     38  * @author jessewilson (at) google.com (Jesse Wilson)
     39  */
     40 final class EncounterImpl<T> implements TypeEncounter<T> {
     41 
     42   private final Errors errors;
     43   private final Lookups lookups;
     44   private List<MembersInjector<? super T>> membersInjectors; // lazy
     45   private List<InjectionListener<? super T>> injectionListeners; // lazy
     46   /*if[AOP]*/
     47   private List<MethodAspect> aspects; // lazy
     48   /*end[AOP]*/
     49   private boolean valid = true;
     50 
     51   EncounterImpl(Errors errors, Lookups lookups) {
     52     this.errors = errors;
     53     this.lookups = lookups;
     54   }
     55 
     56   void invalidate() {
     57     valid = false;
     58   }
     59 
     60   /*if[AOP]*/
     61   ImmutableList<MethodAspect> getAspects() {
     62     return aspects == null
     63         ? ImmutableList.<MethodAspect>of()
     64         : ImmutableList.copyOf(aspects);
     65   }
     66 
     67   public void bindInterceptor(Matcher<? super Method> methodMatcher,
     68       org.aopalliance.intercept.MethodInterceptor... interceptors) {
     69     checkState(valid, "Encounters may not be used after hear() returns.");
     70 
     71     // make sure the applicable aspects is mutable
     72     if (aspects == null) {
     73       aspects = Lists.newArrayList();
     74     }
     75 
     76     aspects.add(new MethodAspect(Matchers.any(), methodMatcher, interceptors));
     77   }
     78   /*end[AOP]*/
     79 
     80   ImmutableSet<MembersInjector<? super T>> getMembersInjectors() {
     81     return membersInjectors == null
     82         ? ImmutableSet.<MembersInjector<? super T>>of()
     83         : ImmutableSet.copyOf(membersInjectors);
     84   }
     85 
     86   ImmutableSet<InjectionListener<? super T>> getInjectionListeners() {
     87     return injectionListeners == null
     88         ? ImmutableSet.<InjectionListener<? super T>>of()
     89         : ImmutableSet.copyOf(injectionListeners);
     90   }
     91 
     92   public void register(MembersInjector<? super T> membersInjector) {
     93     checkState(valid, "Encounters may not be used after hear() returns.");
     94 
     95     if (membersInjectors == null) {
     96       membersInjectors = Lists.newArrayList();
     97     }
     98 
     99     membersInjectors.add(membersInjector);
    100   }
    101 
    102   public void register(InjectionListener<? super T> injectionListener) {
    103     checkState(valid, "Encounters may not be used after hear() returns.");
    104 
    105     if (injectionListeners == null) {
    106       injectionListeners = Lists.newArrayList();
    107     }
    108 
    109     injectionListeners.add(injectionListener);
    110   }
    111 
    112   public void addError(String message, Object... arguments) {
    113     checkState(valid, "Encounters may not be used after hear() returns.");
    114     errors.addMessage(message, arguments);
    115   }
    116 
    117   public void addError(Throwable t) {
    118     checkState(valid, "Encounters may not be used after hear() returns.");
    119     errors.errorInUserCode(t, "An exception was caught and reported. Message: %s", t.getMessage());
    120   }
    121 
    122   public void addError(Message message) {
    123     checkState(valid, "Encounters may not be used after hear() returns.");
    124     errors.addMessage(message);
    125   }
    126 
    127   public <T> Provider<T> getProvider(Key<T> key) {
    128     checkState(valid, "Encounters may not be used after hear() returns.");
    129     return lookups.getProvider(key);
    130   }
    131 
    132   public <T> Provider<T> getProvider(Class<T> type) {
    133     return getProvider(Key.get(type));
    134   }
    135 
    136   public <T> MembersInjector<T> getMembersInjector(TypeLiteral<T> typeLiteral) {
    137     checkState(valid, "Encounters may not be used after hear() returns.");
    138     return lookups.getMembersInjector(typeLiteral);
    139   }
    140 
    141   public <T> MembersInjector<T> getMembersInjector(Class<T> type) {
    142     return getMembersInjector(TypeLiteral.get(type));
    143   }
    144 }