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 }