| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| |
| using System; |
| using System.Collections.Generic; |
| using System.Globalization; |
| using System.Linq; |
| using System.Reflection; |
| using System.Text; |
| using Org.Apache.REEF.Tang.Annotations; |
| using Org.Apache.REEF.Tang.Exceptions; |
| using Org.Apache.REEF.Tang.Implementations.Configuration; |
| using Org.Apache.REEF.Tang.Interface; |
| using Org.Apache.REEF.Tang.Types; |
| using Org.Apache.REEF.Tang.Util; |
| using Org.Apache.REEF.Utilities.Logging; |
| |
| namespace Org.Apache.REEF.Tang.Implementations.InjectionPlan |
| { |
| internal sealed class InjectorImpl : IInjector |
| { |
| private static readonly Logger LOGGER = Logger.GetLogger(typeof(InjectorImpl)); |
| |
| readonly IDictionary<INamedParameterNode, object> namedParameterInstances = new MonotonicTreeMap<INamedParameterNode, object>(); |
| private readonly ICsClassHierarchy classHierarchy; |
| private readonly IConfiguration configuration; |
| readonly IDictionary<IClassNode, object> instances = new MonotonicTreeMap<IClassNode, object>(); |
| private Aspect aspect; |
| private readonly ISet<IInjectionFuture<object>> pendingFutures = new HashSet<IInjectionFuture<object>>(); |
| |
| static readonly InjectionPlan BUILDING = new BuildingInjectionPlan(null); // TODO anonymous class |
| |
| private bool concurrentModificationGuard = false; |
| |
| private void AssertNotConcurrent() |
| { |
| if (concurrentModificationGuard) |
| { |
| // TODO |
| // throw new ConcurrentModificationException("Detected attempt to use Injector from within an injected constructor!"); |
| } |
| } |
| public InjectorImpl(IConfiguration c) |
| { |
| this.configuration = c; |
| this.classHierarchy = (ICsClassHierarchy)c.GetClassHierarchy(); |
| } |
| |
| public object InjectFromPlan(InjectionPlan plan) |
| { |
| if (!plan.IsFeasible()) |
| { |
| var ex = new InjectionException("Cannot inject " + plan.GetNode().GetFullName() + ": " |
| + plan.ToCantInjectString()); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| |
| if (plan.IsAmbiguous()) |
| { |
| var ex = new InjectionException("Cannot inject " + plan.GetNode().GetFullName() + " " |
| + plan.ToCantInjectString()); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| |
| if (plan is InjectionFuturePlan) |
| { |
| InjectionFuturePlan fut = (InjectionFuturePlan)plan; |
| INode node = fut.GetNode(); |
| string key = node.GetFullName(); |
| try |
| { |
| Type t = null; |
| Type nodeType = classHierarchy.ClassForName(node.GetFullName()); |
| |
| if (node is IClassNode) |
| { |
| t = nodeType; |
| } |
| else if (node is INamedParameterNode) |
| { |
| var nn = (INamedParameterNode)node; |
| t = classHierarchy.ClassForName(nn.GetFullArgName()); |
| if (nn.IsSet()) |
| { |
| t = typeof(ISet<>).MakeGenericType(new Type[] { t }); |
| } |
| } |
| else |
| { |
| var ex = new TangApplicationException("Unexpected node type. Wanted ClassNode or NamedParameterNode. Got: " + node); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| |
| // Java - InjectionFuture<?> ret = new InjectionFuture<>(this, javaNamespace.classForName(fut.getNode().getFullName())); |
| // C# - InjectionFuture<object> ret = new InjectionFutureImpl<object>(this, classHierarchy.ClassForName(fut.GetNode().GetFullName())); |
| // We cannot simply create an object from generic with object as <T> |
| // typeof(InjectionFutureImpl<>).MakeGenericType(t) will get the InjectionFutureImpl generic Type with <T> as t |
| // for ClassNode, t is the Type of the class, for NamedParameterNode, t is the Type of the argument |
| // we then use reflection to invoke the constructor |
| // To retain generic argument information?? |
| Type injectionFuture = typeof(InjectionFutureImpl<>).MakeGenericType(t); |
| var constructor = injectionFuture.GetConstructor(new Type[] { typeof(IInjector), typeof(Type) }); |
| IInjectionFuture<object> ret = (IInjectionFuture<object>)constructor.Invoke(new object[] { this, nodeType }); |
| |
| pendingFutures.Add(ret); |
| return ret; |
| } |
| catch (TypeLoadException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new InjectionException("Could not get class for " + key), LOGGER); |
| } |
| } |
| else if (plan.GetNode() is IClassNode && GetCachedInstance((IClassNode)plan.GetNode()) != null) |
| { |
| return GetCachedInstance((IClassNode)plan.GetNode()); |
| } |
| else if (plan is CsInstance) |
| { |
| // TODO: Must be named parameter node. Check. |
| // throw new IllegalStateException("Instance from plan not in Injector's set of instances?!?"); |
| return ((CsInstance)plan).instance; |
| } |
| else if (plan is Constructor) |
| { |
| Constructor constructor = (Constructor)plan; |
| object[] args = new object[constructor.GetArgs().Length]; |
| InjectionPlan[] argPlans = constructor.GetArgs(); |
| |
| for (int i = 0; i < argPlans.Length; i++) |
| { |
| args[i] = InjectFromPlan(argPlans[i]); |
| } |
| |
| try |
| { |
| concurrentModificationGuard = true; |
| object ret = null; |
| try |
| { |
| IConstructorDef def = (IConstructorDef)constructor.GetConstructorDef(); |
| ConstructorInfo c = GetConstructor(def); |
| |
| if (aspect != null) |
| { |
| ret = aspect.Inject(def, c, args); |
| } |
| else |
| { |
| ret = c.Invoke(args); |
| } |
| } |
| catch (ArgumentException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER); |
| StringBuilder sb = new StringBuilder("Internal Tang error? Could not call constructor " + constructor.GetConstructorDef() + " with arguments ["); |
| foreach (object o in args) |
| { |
| sb.Append("\n\t" + o); |
| } |
| sb.Append("]"); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException(sb.ToString(), e), LOGGER); |
| } |
| if (ret is IExternalConstructor<object>) |
| { |
| ret = ((IExternalConstructor<object>)ret).NewInstance(); |
| } |
| instances.Add(constructor.GetNode(), ret); |
| return ret; |
| } |
| catch (TargetInvocationException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new InjectionException("Could not invoke constructor: " + plan, e), LOGGER); |
| } |
| finally |
| { |
| concurrentModificationGuard = false; |
| } |
| } |
| else if (plan is Subplan) |
| { |
| Subplan ambiguous = (Subplan)plan; |
| return InjectFromPlan(ambiguous.GetDelegatedPlan()); |
| } |
| else if (plan is SetInjectionPlan) |
| { |
| SetInjectionPlan setPlan = (SetInjectionPlan)plan; |
| INode n = setPlan.GetNode(); |
| string typeOfSet = null; |
| |
| // TODO: This doesn't work for sets of generics (e.g., Set<Foo<int>> |
| // because GetFullName and GetFullArgName strip generic info). |
| if (n is INamedParameterNode) |
| { |
| INamedParameterNode np = (INamedParameterNode)n; |
| typeOfSet = np.GetFullArgName(); |
| } |
| else if (n is IClassNode) |
| { |
| typeOfSet = n.GetFullName(); |
| } |
| else |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new TangApplicationException("Unknown node type :" + n.ToString()), LOGGER); |
| } |
| |
| Type t = classHierarchy.ClassForName(typeOfSet); |
| |
| // MakeGenericType(t = int: MonotonicHashSet<> -> MonotonicHashSet<int> |
| // Get constructor: MonotonicHashSet<int> -> public MonotonicHashSet<int>() { ... } |
| // Invoke: public MonotonicHashSet<int> -> new MonotonicHashSet<int>() |
| object ret = typeof(MonotonicHashSet<>).MakeGenericType(t).GetConstructor(new Type[] { }).Invoke(new object[] { }); // (this, classHierarchy.ClassForName(fut.GetNode().GetFullName())); |
| |
| MethodInfo mf = ret.GetType().GetMethod("Add"); |
| |
| foreach (InjectionPlan subplan in setPlan.GetEntryPlans()) |
| { |
| // ret.Add(InjectFromPlan(subplan)); |
| mf.Invoke(ret, new object[] { InjectFromPlan(subplan) }); |
| } |
| return ret; |
| } |
| else if (plan is ListInjectionPlan) |
| { |
| ListInjectionPlan listPlan = (ListInjectionPlan)plan; |
| INode n = listPlan.GetNode(); |
| string typeOfList = null; |
| |
| if (n is INamedParameterNode) |
| { |
| INamedParameterNode np = (INamedParameterNode)n; |
| typeOfList = np.GetFullArgName(); |
| } |
| else if (n is IClassNode) |
| { |
| typeOfList = n.GetFullName(); |
| } |
| else |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new TangApplicationException("Unknown node type :" + n.ToString()), LOGGER); |
| } |
| |
| Type t = classHierarchy.ClassForName(typeOfList); |
| object ret = typeof(List<>).MakeGenericType(t).GetConstructor(new Type[] { }).Invoke(new object[] { }); |
| |
| MethodInfo mf = ret.GetType().GetMethod("Add"); |
| |
| foreach (InjectionPlan subplan in listPlan.GetEntryPlans()) |
| { |
| mf.Invoke(ret, new object[] { InjectFromPlan(subplan) }); |
| } |
| return ret; |
| } |
| else |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Unknown plan type: " + plan), LOGGER); |
| } |
| return null; // should never reach here |
| } |
| |
| private object GetCachedInstance(IClassNode cn) |
| { |
| //// if (cn.GetFullName().Equals(ReflectionUtilities.NonGenericFullName(typeof(IInjector)))) |
| if (cn.GetFullName().Equals(ReflectionUtilities.GetAssemblyQualifiedName(typeof(IInjector)))) |
| { |
| return this.ForkInjector(); // TODO: We should be insisting on injection futures here! .forkInjector(); |
| } |
| else |
| { |
| object t = null; |
| |
| instances.TryGetValue(cn, out t); |
| |
| if (t != null && t is IInjectionFuture<object>) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Found an injection future in getCachedInstance: " + cn), LOGGER); |
| } |
| return t; |
| } |
| } |
| |
| private ConstructorInfo GetConstructor(IConstructorDef constructor) |
| { |
| Type clazz = (Type)this.classHierarchy.ClassForName(constructor.GetClassName()); |
| IConstructorArg[] args = constructor.GetArgs().ToArray(); |
| Type[] parameterTypes = new Type[args.Length]; |
| for (int i = 0; i < args.Length; i++) |
| { |
| if (args[i].IsInjectionFuture()) |
| { |
| parameterTypes[i] = typeof(IInjectionFuture<>).MakeGenericType(new Type[] { this.classHierarchy.ClassForName(args[i].Gettype()) }); |
| } |
| else |
| { |
| parameterTypes[i] = this.classHierarchy.ClassForName(args[i].Gettype()); |
| } |
| } |
| |
| ConstructorInfo cons = clazz.GetConstructor(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic, null, parameterTypes, null); |
| |
| //// TODO |
| //// cons.setAccessible(true); |
| |
| if (cons == null) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new TangApplicationException("Failed to look up constructor: " + constructor.ToString()), LOGGER); |
| } |
| return cons; |
| } |
| |
| private void BuildInjectionPlan(INode n, IDictionary<INode, InjectionPlan> memo) |
| { |
| if (memo.ContainsKey(n)) |
| { |
| InjectionPlan p = null; |
| memo.TryGetValue(n, out p); |
| if (BUILDING == p) |
| { |
| StringBuilder loopyList = new StringBuilder("["); |
| foreach (INode node in memo.Keys) |
| { |
| InjectionPlan p1 = null; |
| memo.TryGetValue(node, out p1); |
| if (p1 == BUILDING) |
| { |
| loopyList.Append(" " + node.GetFullName()); |
| } |
| } |
| loopyList.Append(" ]"); |
| var ex = new ClassHierarchyException("Detected loopy constructor involving " |
| + loopyList.ToString()); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| else |
| { |
| return; |
| } |
| } |
| memo.Add(n, BUILDING); |
| InjectionPlan ip = null; |
| if (n is INamedParameterNode) |
| { |
| INamedParameterNode np = (INamedParameterNode)n; |
| object boundInstance = ParseBoundNamedParameter(np); |
| object defaultInstance = this.classHierarchy.ParseDefaultValue(np); |
| object instance = boundInstance != null ? boundInstance : defaultInstance; |
| |
| if (instance is INode) |
| { |
| BuildInjectionPlan((INode)instance, memo); |
| InjectionPlan sp; |
| memo.TryGetValue((INode)instance, out sp); |
| ip = new Subplan(n, 0, new InjectionPlan[] { sp }); |
| } |
| else if (instance is ISet<object>) |
| { |
| ISet<object> entries = (ISet<object>)instance; |
| ip = CreateSetInjectionPlan(n, memo, entries); |
| } |
| else if (instance is ISet<INode>) |
| { |
| ISet<INode> entries = (ISet<INode>)instance; |
| ip = CreateSetInjectionPlan(n, memo, entries); |
| } |
| else if (instance is IList<object>) |
| { |
| IList<object> entries = (IList<object>)instance; |
| ip = CreateListInjectionPlan(n, memo, entries); |
| } |
| else if (instance is IList<INode>) |
| { |
| IList<INode> entries = (IList<INode>)instance; |
| ip = CreateListInjectionPlan(n, memo, entries); |
| } |
| else |
| { |
| ip = new CsInstance(np, instance); |
| } |
| } |
| else if (n is IClassNode) |
| { |
| IClassNode cn = (IClassNode)n; |
| |
| // Any (or all) of the next four values might be null; that's fine. |
| object cached = GetCachedInstance(cn); |
| IClassNode boundImpl = this.configuration.GetBoundImplementation(cn); |
| IClassNode defaultImpl = ParseDefaultImplementation(cn); |
| IClassNode ec = this.configuration.GetBoundConstructor(cn); |
| |
| ip = BuildClassNodeInjectionPlan(cn, cached, ec, boundImpl, defaultImpl, memo); |
| } |
| else if (n is IPackageNode) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ArgumentException( |
| "Request to instantiate Java package as object"), LOGGER); |
| } |
| else |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException( |
| "Type hierarchy contained unknown node type!:" + n), LOGGER); |
| } |
| memo[n] = ip; |
| } |
| |
| private InjectionPlan CreateSetInjectionPlan<T>(INode n, IDictionary<INode, InjectionPlan> memo, ISet<T> entries) |
| { |
| ISet<InjectionPlan> plans = new MonotonicHashSet<InjectionPlan>(); |
| CreateInjectionPlanForCollectionElements(n, memo, entries, plans); |
| return new SetInjectionPlan(n, plans); |
| } |
| |
| private void CreateInjectionPlanForCollectionElements<T>(INode n, IDictionary<INode, InjectionPlan> memo, ICollection<T> entries, ICollection<InjectionPlan> plans) |
| { |
| foreach (var entry in entries) |
| { |
| if (entry is IClassNode) |
| { |
| BuildInjectionPlan((IClassNode)entry, memo); |
| InjectionPlan p2 = null; |
| memo.TryGetValue((INode)entry, out p2); |
| if (p2 != null) |
| { |
| plans.Add(p2); |
| } |
| } |
| else |
| { |
| plans.Add(new CsInstance(n, entry)); |
| } |
| } |
| } |
| |
| private InjectionPlan CreateListInjectionPlan<T>(INode n, IDictionary<INode, InjectionPlan> memo, IList<T> entries) |
| { |
| IList<InjectionPlan> plans = new List<InjectionPlan>(); |
| CreateInjectionPlanForCollectionElements(n, memo, entries, plans); |
| return new ListInjectionPlan(n, plans); |
| } |
| |
| private InjectionPlan BuildClassNodeInjectionPlan(IClassNode cn, |
| object cachedInstance, |
| IClassNode externalConstructor, |
| IClassNode boundImpl, |
| IClassNode defaultImpl, |
| IDictionary<INode, InjectionPlan> memo) |
| { |
| if (cachedInstance != null) |
| { |
| return new CsInstance(cn, cachedInstance); |
| } |
| else if (externalConstructor != null) |
| { |
| BuildInjectionPlan(externalConstructor, memo); |
| InjectionPlan ip = null; |
| memo.TryGetValue(externalConstructor, out ip); |
| return new Subplan(cn, 0, new InjectionPlan[] { ip }); |
| } |
| else if (boundImpl != null && !cn.Equals(boundImpl)) |
| { |
| // We need to delegate to boundImpl, so recurse. |
| BuildInjectionPlan(boundImpl, memo); |
| InjectionPlan ip = null; |
| memo.TryGetValue(boundImpl, out ip); |
| return new Subplan(cn, 0, new InjectionPlan[] { ip }); |
| } |
| else if (defaultImpl != null && !cn.Equals(defaultImpl)) |
| { |
| BuildInjectionPlan(defaultImpl, memo); |
| InjectionPlan ip = null; |
| memo.TryGetValue(defaultImpl, out ip); |
| return new Subplan(cn, 0, new InjectionPlan[] { ip }); |
| } |
| else |
| { |
| // if we're here and there is a bound impl or a default impl, |
| // then we're bound / defaulted to ourselves, so don't add |
| // other impls to the list of things to consider. |
| List<IClassNode> candidateImplementations = new List<IClassNode>(); |
| candidateImplementations.Add(cn); |
| List<InjectionPlan> sub_ips = FilterCandidateConstructors(candidateImplementations, memo); |
| if (sub_ips.Count == 1) |
| { |
| return WrapInjectionPlans(cn, sub_ips, false, -1); |
| } |
| return WrapInjectionPlans(cn, sub_ips, true, -1); |
| } |
| } |
| |
| private List<InjectionPlan> FilterCandidateConstructors( |
| List<IClassNode> candidateImplementations, |
| IDictionary<INode, InjectionPlan> memo) |
| { |
| List<InjectionPlan> sub_ips = new List<InjectionPlan>(); |
| |
| // each implementation |
| foreach (IClassNode thisCN in candidateImplementations) |
| { |
| List<InjectionPlan> constructors = new List<InjectionPlan>(); |
| List<IConstructorDef> constructorList = new List<IConstructorDef>(); |
| if (this.configuration.GetLegacyConstructor(thisCN) != null) |
| { |
| constructorList.Add(this.configuration.GetLegacyConstructor(thisCN)); |
| } |
| |
| foreach (var c in thisCN.GetInjectableConstructors()) |
| { |
| constructorList.Add(c); |
| } |
| |
| // each constructor |
| foreach (IConstructorDef def in constructorList) |
| { |
| List<InjectionPlan> args = new List<InjectionPlan>(); |
| IConstructorArg[] defArgs = def.GetArgs().ToArray<IConstructorArg>(); |
| |
| // each argument |
| foreach (IConstructorArg arg in defArgs) |
| { |
| if (!arg.IsInjectionFuture()) |
| { |
| try |
| { |
| INode argNode = this.classHierarchy.GetNode(arg.GetName()); |
| BuildInjectionPlan(argNode, memo); |
| InjectionPlan ip = null; |
| memo.TryGetValue(argNode, out ip); |
| args.Add(ip); |
| } |
| catch (NameResolutionException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER); |
| |
| var ex = new IllegalStateException("Detected unresolvable " |
| + "constructor arg while building injection plan. " |
| + "This should have been caught earlier!", e); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| } |
| else |
| { |
| try |
| { |
| args.Add(new InjectionFuturePlan(this.classHierarchy.GetNode(arg.GetName()))); |
| } |
| catch (NameResolutionException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER); |
| var ex = new IllegalStateException("Detected unresolvable " |
| + "constructor arg while building injection plan. " |
| + "This should have been caught earlier!", e); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| } |
| } |
| |
| Constructor constructor = new Constructor(thisCN, def, args.ToArray()); |
| constructors.Add(constructor); |
| } |
| |
| // The constructors are embedded in a lattice defined by |
| // isMoreSpecificThan(). We want to see if, amongst the injectable |
| // plans, there is a unique dominant plan, and select it. |
| // First, compute the set of injectable plans. |
| List<int> liveIndices = new List<int>(); |
| for (int i = 0; i < constructors.Count; i++) |
| { |
| if (constructors[i].GetNumAlternatives() > 0) |
| { |
| liveIndices.Add(i); |
| } |
| } |
| |
| // Now, do an all-by-all comparison, removing indices that are dominated |
| // by others. |
| int k = -1; |
| for (int i = 0; i < liveIndices.Count; i++) |
| { |
| for (int j = i + 1; j < liveIndices.Count; j++) |
| { |
| IConstructorDef ci = ((Constructor)constructors[liveIndices[i]]).GetConstructorDef(); |
| IConstructorDef cj = ((Constructor)constructors[liveIndices[j]]).GetConstructorDef(); |
| |
| if (ci.IsMoreSpecificThan(cj)) |
| { |
| // ci's arguments is a superset of cj's |
| k = i; |
| } |
| else if (cj.IsMoreSpecificThan(ci)) |
| { |
| k = j; |
| } |
| } |
| } |
| if (liveIndices.Count == 1) |
| { |
| k = 0; |
| } |
| if (constructors.Count > 0) |
| { |
| sub_ips.Add(WrapInjectionPlans(thisCN, constructors, false, k != -1 ? liveIndices[k] : -1)); |
| } |
| } |
| return sub_ips; |
| } |
| |
| private InjectionPlan WrapInjectionPlans(IClassNode infeasibleNode, |
| List<InjectionPlan> list, bool forceAmbiguous, int selectedIndex) |
| { |
| if (list.Count == 0) |
| { |
| return new Subplan(infeasibleNode, new InjectionPlan[] { }); |
| } |
| else if ((!forceAmbiguous) && list.Count == 1) |
| { |
| return list[0]; |
| } |
| else |
| { |
| return new Subplan(infeasibleNode, selectedIndex, list.ToArray()); |
| } |
| } |
| |
| private IClassNode ParseDefaultImplementation(IClassNode cn) |
| { |
| if (cn.GetDefaultImplementation() != null) |
| { |
| try |
| { |
| return (IClassNode)this.classHierarchy.GetNode(cn.GetDefaultImplementation()); |
| } |
| catch (NameResolutionException e) |
| { |
| var ex = new IllegalStateException("After validation, " + cn + " had a bad default implementation named " + cn.GetDefaultImplementation(), e); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.CaughtAndThrow(ex, Level.Error, LOGGER); |
| } |
| } |
| return null; |
| } |
| |
| private object ParseBoundNamedParameter(INamedParameterNode np) |
| { |
| ISet<object> boundSet = this.configuration.GetBoundSet((INamedParameterNode)np); |
| if (boundSet.Count != 0) |
| { |
| ISet<INode> ret3 = new MonotonicSet<INode>(); |
| ISet<object> ret2 = new MonotonicSet<object>(); |
| return ParseElementsInCollection(np, boundSet, ret3, ret2); |
| } |
| |
| IList<object> boundList = this.configuration.GetBoundList((INamedParameterNode)np); |
| if (boundList != null && boundList.Count != 0) |
| { |
| IList<INode> ret3 = new List<INode>(); |
| IList<object> ret2 = new List<object>(); |
| return ParseElementsInCollection(np, boundList, ret3, ret2); |
| } |
| |
| object ret = null; |
| if (namedParameterInstances.ContainsKey(np)) |
| { |
| namedParameterInstances.TryGetValue(np, out ret); |
| } |
| else |
| { |
| string value = this.configuration.GetNamedParameter(np); |
| if (value == null) |
| { |
| ret = null; |
| } |
| else |
| { |
| try |
| { |
| ret = this.classHierarchy.Parse(np, value); |
| namedParameterInstances.Add(np, ret); |
| } |
| catch (BindException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.CaughtAndThrow(new IllegalStateException( |
| "Could not parse pre-validated value", e), Level.Error, LOGGER); |
| } |
| } |
| } |
| return ret; |
| } |
| |
| private object ParseElementsInCollection(INamedParameterNode np, ICollection<object> boundSet, ICollection<INode> ret3, ICollection<object> ret2) |
| { |
| foreach (object o in boundSet) |
| { |
| if (o is string) |
| { |
| try |
| { |
| var r = this.classHierarchy.Parse(np, (string)o); |
| if (r is INode) |
| { |
| ret3.Add((INode)r); |
| } |
| else |
| { |
| ret2.Add(r); |
| } |
| } |
| catch (ParseException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER); |
| var ex = |
| new IllegalStateException("Could not parse " + o + " which was passed into " + np + |
| " FIXME: Parsability is not currently checked by bindSetEntry(Node,String)"); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| } |
| else if (o is INode) |
| { |
| var o2 = o as INode; |
| ret3.Add(o2); |
| } |
| else |
| { |
| var ex = |
| new IllegalStateException("Unexpected object " + o + |
| " in bound set. Should consist of nodes and strings"); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| } |
| if (ret2.Count > 0 && ret3.Count == 0) |
| { |
| return ret2; |
| } |
| if (ret3.Count > 0 && ret2.Count == 0) |
| { |
| return ret3; |
| } |
| if (ret2.Count > 0 && ret3.Count > 0) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new TangApplicationException("Set contains different types of object"), LOGGER); |
| } |
| return ret2; |
| } |
| |
| public object GetInstance(Type iface) |
| { |
| return GetInstance(ReflectionUtilities.GetAssemblyQualifiedName(iface)); |
| } |
| |
| public T GetInstance<T>() where T : class |
| { |
| return (T)GetInstance(ReflectionUtilities.GetAssemblyQualifiedName(typeof(T))); |
| } |
| |
| private void CheckNamedParameter(Type t) |
| { |
| if (ReflectionUtilities.IsAssignableFromIgnoreGeneric(typeof(Name<>), t)) |
| { |
| var ex = new InjectionException("GetInstance() called on Name " |
| + ReflectionUtilities.GetName(t) |
| + " Did you mean to call GetNamedInstance() instead?"); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| } |
| |
| private object GetInstance(INode node) |
| { |
| InjectionPlan plan = (InjectionPlan)GetInjectionPlan(node); |
| object u = InjectFromPlan(plan); |
| |
| while (pendingFutures.Count != 0) |
| { |
| IEnumerator<object> i = pendingFutures.GetEnumerator(); |
| i.MoveNext(); |
| IInjectionFuture<object> f = (IInjectionFuture<object>)i.Current; |
| pendingFutures.Remove(f); |
| f.Get(); |
| } |
| return u; |
| } |
| |
| public object GetInstance(string clazz) |
| { |
| CheckNamedParameter(ReflectionUtilities.GetTypeByName(clazz)); |
| return GetInstance(classHierarchy.GetNode(clazz)); |
| } |
| |
| public U GetNamedInstance<T, U>(GenericType<T> clazz) where T : Name<U> |
| { |
| Type t = typeof(T); |
| return (U)GetInstance(classHierarchy.GetNode(t)); |
| } |
| |
| public U GetNamedInstance<T, U>() where T : Name<U> |
| { |
| Type t = typeof(T); |
| return (U)GetInstance(classHierarchy.GetNode(t)); |
| } |
| |
| public object GetNamedInstance(Type t) |
| { |
| if (!ReflectionUtilities.IsAssignableFromIgnoreGeneric(typeof(Name<>), t)) |
| { |
| var ex = new TangApplicationException(string.Format(CultureInfo.CurrentCulture, "The parameter {0} is not inherit from Name<>", t)); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| return GetInstance(classHierarchy.GetNode(t)); |
| } |
| |
| public InjectionPlan GetInjectionPlan(Type name) |
| { |
| return GetInjectionPlan(this.classHierarchy.GetNode(name)); |
| } |
| |
| public InjectionPlan GetInjectionPlan(INode n) |
| { |
| AssertNotConcurrent(); |
| IDictionary<INode, InjectionPlan> memo = new Dictionary<INode, InjectionPlan>(); |
| BuildInjectionPlan(n, memo); |
| |
| InjectionPlan p = null; |
| memo.TryGetValue(n, out p); |
| |
| if (p != null) |
| { |
| return p; |
| } |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new InjectionException("Fail to get injection plan" + n), LOGGER); |
| return null; // this line should be not reached as Throw throws exception |
| } |
| |
| public bool IsInjectable(string name) |
| { |
| return GetInjectionPlan(this.classHierarchy.GetNode(name)).IsInjectable(); |
| } |
| |
| public bool IsParameterSet(string name) |
| { |
| InjectionPlan p = GetInjectionPlan(classHierarchy.GetNode(name)); |
| return p.IsInjectable(); |
| } |
| |
| public bool IsInjectable(Type clazz) |
| { |
| AssertNotConcurrent(); |
| try |
| { |
| return IsInjectable(ReflectionUtilities.GetAssemblyQualifiedName(clazz)); |
| } |
| catch (NameResolutionException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Could not round trip " + clazz + " through ClassHierarchy", e), LOGGER); |
| return false; |
| } |
| } |
| |
| public bool IsParameterSet(Type name) |
| { |
| return IsParameterSet(ReflectionUtilities.GetAssemblyQualifiedName(name)); |
| } |
| |
| public void BindAspect(Aspect a) |
| { |
| if (aspect != null) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new BindException("Attempt to re-bind aspect! old=" + aspect + " new=" + a), LOGGER); |
| } |
| aspect = a; |
| } |
| |
| public Aspect GetAspect() |
| { |
| return aspect; |
| } |
| |
| public IInjector ForkInjector() |
| { |
| try |
| { |
| return ForkInjector(new ConfigurationImpl[0]); |
| } |
| catch (BindException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Error in forking injector.", e), LOGGER); |
| return null; |
| } |
| } |
| |
| public IInjector ForkInjector(params IConfiguration[] configurations) |
| { |
| InjectorImpl ret; |
| ret = Copy(this, configurations); |
| return ret; |
| } |
| |
| private static InjectorImpl Copy(InjectorImpl old, IConfiguration[] configurations) |
| { |
| InjectorImpl injector = null; |
| try |
| { |
| IConfigurationBuilder cb = old.configuration.newBuilder(); |
| foreach (IConfiguration c in configurations) |
| { |
| cb.AddConfiguration(c); |
| } |
| injector = new InjectorImpl(cb.Build()); |
| } |
| catch (BindException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Unexpected error copying configuration!", e), LOGGER); |
| } |
| |
| foreach (IClassNode cn in old.instances.Keys) |
| { |
| if (cn.GetFullName().Equals(ReflectionUtilities.GetAssemblyQualifiedName(typeof(IInjector))) |
| || cn.GetFullName().Equals(ReflectionUtilities.GetAssemblyQualifiedName(typeof(InjectorImpl)))) |
| { |
| // This would imply that we're treating injector as a singleton somewhere. It should be copied fresh each time. |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException(string.Empty), LOGGER); |
| } |
| try |
| { |
| IClassNode new_cn = (IClassNode)injector.classHierarchy.GetNode(cn.GetFullName()); |
| |
| object o = null; |
| old.instances.TryGetValue(cn, out o); |
| if (o != null) |
| { |
| injector.instances.Add(new_cn, o); |
| } |
| } |
| catch (BindException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Could not resolve name " |
| + cn.GetFullName() + " when copying injector", e), LOGGER); |
| } |
| } |
| |
| foreach (INamedParameterNode np in old.namedParameterInstances.Keys) |
| { |
| // if (!builder.namedParameters.containsKey(np)) { |
| object o = null; |
| old.namedParameterInstances.TryGetValue(np, out o); |
| INamedParameterNode new_np = (INamedParameterNode)injector.classHierarchy.GetNode(np.GetFullName()); |
| injector.namedParameterInstances.Add(new_np, o); |
| } |
| |
| // Fork the aspect (if any) |
| if (old.aspect != null) |
| { |
| injector.BindAspect(old.aspect.CreateChildAspect()); |
| } |
| return injector; |
| } |
| |
| void BindVolatileInstanceNoCopy<T>(GenericType<T> c, T o) |
| { |
| AssertNotConcurrent(); |
| INode n = this.classHierarchy.GetNode(typeof(T)); |
| if (n is IClassNode) |
| { |
| IClassNode cn = (IClassNode)n; |
| object old = GetCachedInstance(cn); |
| if (old != null) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new BindException("Attempt to re-bind instance. Old value was " |
| + old + " new value is " + o), LOGGER); |
| } |
| instances.Add(cn, o); |
| } |
| else |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ArgumentException("Expected Class but got " + c |
| + " (probably a named parameter)."), LOGGER); |
| } |
| } |
| |
| // void BindVolatileParameterNoCopy(Class<? extends Name<T>> c, T o) |
| void BindVolatileParameterNoCopy<U, T>(GenericType<U> c, T o) |
| where U : Name<T> |
| { |
| INode n = this.classHierarchy.GetNode(typeof(U)); |
| if (n is INamedParameterNode) |
| { |
| INamedParameterNode np = (INamedParameterNode)n; |
| object old = this.configuration.GetNamedParameter(np); |
| if (old != null) |
| { |
| // XXX need to get the binding site here! |
| var ex = new BindException( |
| "Attempt to re-bind named parameter " + ReflectionUtilities.GetAssemblyQualifiedName(typeof(U)) + ". Old value was [" + old |
| + "] new value is [" + o + "]"); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| try |
| { |
| namedParameterInstances.Add(np, o); |
| } |
| catch (ArgumentException e) |
| { |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER); |
| var ex = new BindException( |
| "Attempt to re-bind named parameter " + ReflectionUtilities.GetAssemblyQualifiedName(typeof(U)) + ". Old value was [" + old |
| + "] new value is [" + o + "]"); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| } |
| else |
| { |
| var ex = new ArgumentException("Expected Name, got " + typeof(U) + " (probably a class)"); |
| Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); |
| } |
| } |
| |
| // public <T> void bindVolatileInstance(Class<T> c, T o) throws BindException { |
| public void BindVolatileInstance<T>(GenericType<T> iface, T inst) |
| { |
| BindVolatileInstanceNoCopy(iface, inst); |
| } |
| |
| /// <summary> |
| /// Binds the volatile instance. |
| /// </summary> |
| /// <typeparam name="T"></typeparam> |
| /// <param name="inst">The inst.</param> |
| public void BindVolatileInstance<T>(T inst) |
| { |
| BindVolatileInstance<T>(GenericType<T>.Class, inst); |
| } |
| |
| /// <summary> |
| /// Binds the volatile parameter. |
| /// </summary> |
| /// <typeparam name="U"></typeparam> |
| /// <typeparam name="T"></typeparam> |
| /// <param name="iface">The iface.</param> |
| /// <param name="inst">The inst.</param> |
| public void BindVolatileParameter<U, T>(GenericType<U> iface, T inst) where U : Name<T> |
| { |
| BindVolatileParameterNoCopy(iface, inst); |
| } |
| |
| /// <summary> |
| /// Binds the volatile parameter. |
| /// </summary> |
| /// <typeparam name="U"></typeparam> |
| /// <typeparam name="T"></typeparam> |
| /// <param name="inst">The inst.</param> |
| public void BindVolatileParameter<U, T>(T inst) where U : Name<T> |
| { |
| BindVolatileParameter(GenericType<U>.Class, inst); |
| } |
| |
| ////public T GetNamedParameter<U, T>(GenericType<U> name) where U : Name<T> |
| ////{ |
| //// return (T)GetNamedInstance(typeof(U)); |
| ////} |
| |
| ////public IInjector CreateChildInjector(IConfiguration[] configurations) |
| ////{ |
| //// return ForkInjector(configurations); |
| ////} |
| |
| /// <summary> |
| /// Gets the injection plan for a given class name |
| /// </summary> |
| /// <param name="name">The name.</param> |
| /// <returns></returns> |
| public InjectionPlan GetInjectionPlan(string name) |
| { |
| return GetInjectionPlan(this.classHierarchy.GetNode(name)); |
| } |
| } |
| } |
