public static Org.Apache.REEF.Tang.Protobuf.InjectionPlan Serialize(Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan ip) { if (ip is Org.Apache.REEF.Tang.Implementations.InjectionPlan.Constructor) { Org.Apache.REEF.Tang.Implementations.InjectionPlan.Constructor cons = (Org.Apache.REEF.Tang.Implementations.InjectionPlan.Constructor)ip; Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan[] args = cons.GetArgs(); Org.Apache.REEF.Tang.Protobuf.InjectionPlan[] protoArgs = new Org.Apache.REEF.Tang.Protobuf.InjectionPlan[args.Length]; for (int i = 0; i < args.Length; i++) { protoArgs[i] = Serialize(args[i]); } return(NewConstructor(ip.GetNode().GetFullName(), protoArgs.ToList <Org.Apache.REEF.Tang.Protobuf.InjectionPlan>())); } if (ip is Org.Apache.REEF.Tang.Implementations.InjectionPlan.Subplan) { Org.Apache.REEF.Tang.Implementations.InjectionPlan.Subplan sp = (Org.Apache.REEF.Tang.Implementations.InjectionPlan.Subplan)ip; Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan[] args = sp.GetPlans(); Org.Apache.REEF.Tang.Protobuf.InjectionPlan[] subPlans = new Org.Apache.REEF.Tang.Protobuf.InjectionPlan[args.Length]; for (int i = 0; i < args.Length; i++) { subPlans[i] = Serialize(args[i]); } return(NewSubplan(ip.GetNode().GetFullName(), sp.GetSelectedIndex(), subPlans.ToList <Org.Apache.REEF.Tang.Protobuf.InjectionPlan>())); } if (ip is CsInstance) { CsInstance ji = (CsInstance)ip; return(NewInstance(ip.GetNode().GetFullName(), ji.GetInstanceAsString())); } Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException( "Encountered unknown type of InjectionPlan: " + ip), LOGGER); return(null); }
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 ApplicationException("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 && null != GetCachedInstance((IClassNode)plan.GetNode())) { 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 ApplicationException("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 ApplicationException("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 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 (null != this.configuration.GetLegacyConstructor(thisCN)) { 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); }