public void TestNameCantBindSubclassOfArgumentAsDefault() { ns = TangFactory.GetTang().GetClassHierarchy(new string[] { FileNames.Examples, FileNames.Common, FileNames.Tasks }); INode node = ns.GetNode(typeof(GoodNameForGeneric).AssemblyQualifiedName); Assert.Equal(node.GetFullName(), typeof(GoodNameForGeneric).AssemblyQualifiedName); }
public void TestDeserializedConfigMerge() { Type activityInterfaceType = typeof(ITask); ITang tang = TangFactory.GetTang(); ICsConfigurationBuilder cb1 = tang.NewConfigurationBuilder(); cb1.BindImplementation(GenericType <ITask> .Class, GenericType <HelloTask> .Class); cb1.BindNamedParameter <TaskConfigurationOptions.Identifier, string>( GenericType <TaskConfigurationOptions.Identifier> .Class, "Hello Task"); IConfiguration conf1 = cb1.Build(); var serializer = new AvroConfigurationSerializer(); serializer.ToFile(conf1, "task.config"); ICsConfigurationBuilder cb2 = tang.NewConfigurationBuilder(); cb2.BindNamedParameter <Timer.Seconds, int>(GenericType <Timer.Seconds> .Class, "2"); IConfiguration conf2 = cb2.Build(); serializer.ToFile(conf2, "timer.config"); ProtocolBufferClassHierarchy.Serialize("TaskTimer.bin", conf1.GetClassHierarchy()); IClassHierarchy ns = ProtocolBufferClassHierarchy.DeSerialize("TaskTimer.bin"); AvroConfiguration taskAvroconfiguration = serializer.AvroDeserializeFromFile("task.config"); IConfiguration taskConfiguration = serializer.FromAvro(taskAvroconfiguration, ns); AvroConfiguration timerAvroconfiguration = serializer.AvroDeserializeFromFile("timer.config"); IConfiguration timerConfiguration = serializer.FromAvro(timerAvroconfiguration, ns); IConfiguration merged = Configurations.MergeDeserializedConfs(taskConfiguration, timerConfiguration); var b = merged.newBuilder().Build(); }
public void TestSerializeClassHierarchy() { IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { @"Com.Microsoft.Tang.Examples" }); IClassNode timerClassNode = (IClassNode)ns.GetNode("Com.Microsoft.Tang.Examples.Timer"); ProtocolBufferClassHierarchy.Serialize("node.bin", ns); }
public TestClassHierarchy() { if (ns == null) { ns = TangFactory.GetTang().GetClassHierarchy(new string[] { FileNames.Examples, FileNames.Common, FileNames.Tasks }); } }
public IClassHierarchy Merge(IClassHierarchy ch) { if (this == ch) { return(this); } if (!(ch is ClassHierarchyImpl)) { Org.Apache.Reef.Utilities.Diagnostics.Exceptions.Throw(new NotSupportedException("Can't merge java and non-java class hierarchies yet!"), LOGGER); } if (this.assemblies.Count == 0) { return(ch); } ClassHierarchyImpl chi = (ClassHierarchyImpl)ch; MonotonicHashSet <string> otherJars = new MonotonicHashSet <string>(); otherJars.AddAll(chi.assemblies); MonotonicHashSet <string> myJars = new MonotonicHashSet <string>(); myJars.AddAll(this.assemblies); if (myJars.ContainsAll(otherJars)) { return(this); } if (otherJars.ContainsAll(myJars)) { return(ch); } myJars.AddAll(otherJars); return(new ClassHierarchyImpl(myJars.ToArray())); }
public void TestToTextFileForTask() { IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(HelloTask).Assembly.GetName().Name }); _serializer.ToTextFile(ns, "avroTask.bin"); Assert.True(File.Exists("avroTask.bin")); }
public void TestToString() { IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(HelloTask).Assembly.GetName().Name }); string s = _serializer.ToString(ns); Assert.NotNull(s); }
/// <summary> /// Serialize a ClassHierarchy into a Json string /// </summary> /// <param name="c"></param> /// <returns></returns> public string ToString(IClassHierarchy c) { AvroNode obj = ToAvroNode(c); string s = JsonConvert.SerializeObject(obj, Formatting.Indented); return(s); }
public void TestDeSerializeClassHierarchyAndBind() { Type streamTask1Type = typeof(StreamTask1); Type helloTaskType = typeof(HelloTask); IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(HelloTask).Assembly.GetName().Name }); IClassNode StreamTask1ClassNode = (IClassNode)ns.GetNode(streamTask1Type.AssemblyQualifiedName); IClassNode HelloTaskClassNode = (IClassNode)ns.GetNode(helloTaskType.AssemblyQualifiedName); ProtocolBufferClassHierarchy.Serialize("task.bin", ns); IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize("task.bin"); IClassNode StreamTask1ClassNode2 = (IClassNode)ch.GetNode(streamTask1Type.AssemblyQualifiedName); IClassNode HelloTaskClassNode2 = (IClassNode)ch.GetNode(helloTaskType.AssemblyQualifiedName); Assert.Equal(StreamTask1ClassNode.GetName(), StreamTask1ClassNode2.GetName()); Assert.Equal(HelloTaskClassNode.GetName(), HelloTaskClassNode2.GetName()); // have to use original class hierarchy for the merge. ClassHierarchy from ProtoBuffer doesn't support merge. IConfigurationBuilder cb = TangFactory.GetTang() .NewConfigurationBuilder(ns); cb.AddConfiguration(TaskConfiguration.ConfigurationModule .Set(TaskConfiguration.Identifier, "Hello_From_Streaming1") .Set(TaskConfiguration.Task, GenericType <StreamTask1> .Class) .Build()); IConfiguration taskConfiguration = cb.Build(); StreamTask1 st = TangFactory.GetTang().NewInjector(taskConfiguration).GetInstance <StreamTask1>(); Assert.NotNull(st); }
/// <summary> /// Serialize a ClassHierarchy into a text file as Json string /// </summary> /// <param name="c"></param> /// <param name="fileName"></param> public void ToTextFile(IClassHierarchy c, string fileName) { var fp = new StreamWriter(fileName); fp.WriteLine(ToString(c)); fp.Close(); }
public void TestDeSerializeClassHierarchy() { Type timerType = typeof(Timer); Type SecondType = typeof(Timer.Seconds); Type simpleCOnstuctorType = typeof(SimpleConstructors); IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(Timer).Assembly.GetName().Name }); IClassNode timerClassNode = (IClassNode)ns.GetNode(timerType.AssemblyQualifiedName); INode secondNode = (INode)ns.GetNode(SecondType.AssemblyQualifiedName); IClassNode SimpleConstructorsClassNode = (IClassNode)ns.GetNode(simpleCOnstuctorType.AssemblyQualifiedName); ProtocolBufferClassHierarchy.Serialize("node.bin", ns); IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize("node.bin"); IClassNode timerClassNode2 = (IClassNode)ch.GetNode(timerType.AssemblyQualifiedName); INode secondNode2 = ch.GetNode(SecondType.AssemblyQualifiedName); IClassNode SimpleConstructorsClassNode2 = (IClassNode)ch.GetNode(simpleCOnstuctorType.AssemblyQualifiedName); Assert.Equal(timerClassNode.GetFullName(), timerClassNode2.GetFullName()); Assert.Equal(secondNode.GetFullName(), secondNode2.GetFullName()); Assert.Equal(SimpleConstructorsClassNode.GetFullName(), SimpleConstructorsClassNode2.GetFullName()); Assert.True(SimpleConstructorsClassNode2.GetChildren().Count == 0); IList <IConstructorDef> def = SimpleConstructorsClassNode2.GetInjectableConstructors(); Assert.Equal(3, def.Count); }
public static InjectionPlan Deserialize(IClassHierarchy ch, InjectionPlanProto.InjectionPlan ip) { string fullName = ip.name; if (ip.constructor != null) { InjectionPlanProto.Constructor cons = ip.constructor; IClassNode cn = (IClassNode)ch.GetNode(fullName); InjectionPlanProto.InjectionPlan[] protoBufArgs = cons.args.ToArray(); IClassNode[] cnArgs = new IClassNode[protoBufArgs.Length]; for (int i = 0; i < protoBufArgs.Length; i++) { INode no = ch.GetNode(protoBufArgs[i].name); if (no is IClassNode) { cnArgs[i] = (IClassNode)no; } else if (no is INamedParameterNode) { INamedParameterNode np = (INamedParameterNode)no; cnArgs[i] = (IClassNode)ch.GetNode(np.GetFullArgName()); } } InjectionPlan[] ipArgs = new InjectionPlan[protoBufArgs.Length]; for (int i = 0; i < protoBufArgs.Length; i++) { ipArgs[i] = (InjectionPlan)Deserialize(ch, protoBufArgs[i]); } IConstructorDef constructor = cn.GetConstructorDef(cnArgs); return(new Constructor(cn, constructor, ipArgs)); } if (ip.instance != null) { InjectionPlanProto.Instance ins = ip.instance; object instance = Parse(ip.name, ins.value); return(new CsInstance(ch.GetNode(ip.name), instance)); } if (ip.subplan != null) { InjectionPlanProto.Subplan subplan = ip.subplan; InjectionPlanProto.InjectionPlan[] protoBufPlans = subplan.plans.ToArray(); InjectionPlan[] subPlans = new InjectionPlan[protoBufPlans.Length]; for (int i = 0; i < protoBufPlans.Length; i++) { subPlans[i] = (InjectionPlan)Deserialize(ch, protoBufPlans[i]); } INode n = ch.GetNode(fullName); return(new Subplan(n, subPlans)); } Org.Apache.Reef.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Encountered unknown type of InjectionPlan: " + ip), LOGGER); return(null); }
public void TestDeSerializeClassHierarchyFromJava() { //the file comes from Java TestClassHierarchyRoundTrip SetUp3 testSimpleConstructors IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize("simpleConstructorJavaProto.bin"); IClassNode simpleConstructorNode = (IClassNode)ch.GetNode("org.apache.reef.tang.implementation.SimpleConstructors"); Assert.AreEqual(simpleConstructorNode.GetChildren().Count, 0); Assert.AreEqual(simpleConstructorNode.GetInjectableConstructors().Count, 3); }
public void TestSerializeClassHierarchyForAvro() { IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(Microsoft.Hadoop.Avro.AvroSerializer).Assembly.GetName().Name }); Assert.IsNotNull(ns); ProtocolBufferClassHierarchy.Serialize("avro.bin", ns); IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize("avro.bin"); Assert.IsNotNull(ch); }
protected ConfigurationBuilderImpl(string[] assemblies, IConfiguration[] confs, Type[] parsers) { this.ClassHierarchy = TangFactory.GetTang().GetDefaultClassHierarchy(assemblies, parsers); foreach (IConfiguration tc in confs) { AddConfiguration(((ConfigurationImpl) tc)); } }
protected ConfigurationBuilderImpl(string[] assemblies, IConfiguration[] confs, Type[] parsers) { this.ClassHierarchy = TangFactory.GetTang().GetDefaultClassHierarchy(assemblies, parsers); foreach (IConfiguration tc in confs) { AddConfiguration(((ConfigurationImpl)tc)); } }
public static void Serialize(string fileName, IClassHierarchy classHierarchy) { Org.Apache.REEF.Tang.Protobuf.Node node = Serialize(classHierarchy); using (var file = File.Create(fileName)) { Serializer.Serialize <Org.Apache.REEF.Tang.Protobuf.Node>(file, node); } }
public IClassHierarchy Merge(IClassHierarchy ch) { if (this.assemblies.Count == 0) { return(ch); } return(ch);//TODO }
/// <summary> /// Serialize a ClassHierarchy into a text file as Json string /// </summary> /// <param name="c"></param> /// <param name="fileName"></param> public void ToTextFile(IClassHierarchy c, string fileName) { using (FileStream fs = File.Open(fileName, FileMode.Create)) { var fp = new StreamWriter(fs); fp.WriteLine(ToString(c)); fp.Dispose(); } }
public static void Serialize(string fileName, IClassHierarchy classHierarchy) { Org.Apache.REEF.Tang.Protobuf.Node node = Serialize(classHierarchy); using (var file = File.Create(fileName)) { Serializer.Serialize<Org.Apache.REEF.Tang.Protobuf.Node>(file, node); } }
public static void Serialize(string fileName, IClassHierarchy classHierarchy) { Node node = Serialize(classHierarchy); using (var file = File.Create(fileName)) { Serializer.Serialize<Node>(file, node); } }
public static void Serialize(string fileName, IClassHierarchy classHierarchy) { Node node = Serialize(classHierarchy); using (var file = File.Create(fileName)) { Serializer.Serialize <Node>(file, node); } }
public IClassHierarchy Merge(IClassHierarchy ch) { if (this == ch) { return(this); } throw new UnsupportedOperationException( "Cannot merge ExternalClassHierarchies yet!"); }
private void AddConfiguration(IClassHierarchy ns, ConfigurationBuilderImpl builder) { this.ClassHierarchy = this.ClassHierarchy.Merge(ns); //TODO //((ClassHierarchyImpl) ClassHierarchy).parameterParser // .mergeIn(((ClassHierarchyImpl) namespace).parameterParser); foreach (IClassNode cn in builder.BoundImpls.Keys) { IClassNode n = null; builder.BoundImpls.TryGetValue(cn, out n); if (n != null) { Bind(cn.GetFullName(), n.GetFullName()); } } foreach (IClassNode cn in builder.BoundConstructors.Keys) { IClassNode n = null; builder.BoundConstructors.TryGetValue(cn, out n); if (n != null) { Bind(cn.GetFullName(), n.GetFullName()); } } // The namedParameters set contains the strings that can be used to // instantiate new // named parameter instances. Create new ones where we can. foreach (INamedParameterNode np in builder.NamedParameters.Keys) { string v = null; builder.NamedParameters.TryGetValue(np, out v); Bind(np.GetFullName(), v); } foreach (IClassNode cn in builder.LegacyConstructors.Keys) { IConstructorDef cd = null; builder.LegacyConstructors.TryGetValue(cn, out cd); //RegisterLegacyConstructor(cn, cd.GetArgs()); TODO } //for (Entry<NamedParameterNode<Set<?>>, Object> e: builder.boundSetEntries) { // String name = ((NamedParameterNode<Set<T>>)(NamedParameterNode<?>)e.getKey()).getFullName(); // if(e.getValue() instanceof Node) { // bindSetEntry(name, (Node)e.getValue()); // } else if(e.getValue() instanceof String) { // bindSetEntry(name, (String)e.getValue()); // } else { // throw new IllegalStateException(); // } //} }
public static void GenerateClassHierarchy(ISet <string> clrDlls) { using (LOGGER.LogFunction("ClrHandlerHelper::GenerateClassHierarchy")) { IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(clrDlls.ToArray()); ProtocolBufferClassHierarchy.Serialize(Constants.ClassHierarchyBin, ns); LOGGER.Log(Level.Info, "Class hierarchy written to [{0}].", Path.Combine(Directory.GetCurrentDirectory(), Constants.ClassHierarchyBin)); } }
public ConfigurationBuilderImpl(ConfigurationBuilderImpl t) { this.ClassHierarchy = t.GetClassHierarchy(); try { AddConfiguration(t.GetClassHierarchy(), t); } catch (BindException e) { throw new IllegalStateException("Could not copy builder", e); } }
public static InjectionPlan DeSerialize(string fileName, IClassHierarchy ch) { InjectionPlanProto.InjectionPlan protoPlan; using (var file = File.OpenRead(fileName)) { protoPlan = Serializer.Deserialize<InjectionPlanProto.InjectionPlan>(file); } return Deserialize(ch, protoPlan); }
public static InjectionPlan DeSerialize(string fileName, IClassHierarchy ch) { InjectionPlanProto.InjectionPlan protoPlan; using (var file = File.OpenRead(fileName)) { protoPlan = Serializer.Deserialize <InjectionPlanProto.InjectionPlan>(file); } return(Deserialize(ch, protoPlan)); }
public void TestGenericClass() { IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { typeof(Timer).Assembly.GetName().Name }); Type t = typeof(Timer); IClassNode EventClassNode = (IClassNode)ns.GetNode(t.AssemblyQualifiedName); ProtocolBufferClassHierarchy.Serialize("event.bin", ns); IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize("event.bin"); IClassNode EventClassNode1 = (IClassNode)ns.GetNode(t.AssemblyQualifiedName); Assert.AreEqual(EventClassNode.GetName(), EventClassNode1.GetName()); }
public ConfigurationBuilderImpl(ConfigurationBuilderImpl t) { this.ClassHierarchy = t.GetClassHierarchy(); try { AddConfiguration(t.GetClassHierarchy(), t); } 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 copy builder", e), LOGGER); } }
public ConfigurationBuilderImpl(ConfigurationBuilderImpl t) { this.ClassHierarchy = t.GetClassHierarchy(); try { AddConfiguration(t.GetClassHierarchy(), t); } 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 copy builder", e), LOGGER); } }
public static InjectionPlan Deserialize(IClassHierarchy ch, InjectionPlanProto.InjectionPlan ip) { string fullName = ip.name; if (ip.constructor != null) { InjectionPlanProto.Constructor cons = ip.constructor; IClassNode cn = (IClassNode)ch.GetNode(fullName); InjectionPlanProto.InjectionPlan[] protoBufArgs = cons.args.ToArray(); INode[] cnArgs = new INode[protoBufArgs.Length]; for (int i = 0; i < protoBufArgs.Length; i++) { cnArgs[i] = (INode)ch.GetNode(protoBufArgs[i].name); } InjectionPlan[] ipArgs = new InjectionPlan[protoBufArgs.Length]; for (int i = 0; i < protoBufArgs.Length; i++) { ipArgs[i] = (InjectionPlan)Deserialize(ch, protoBufArgs[i]); } IConstructorDef constructor = cn.GetConstructorDef(cnArgs); return(new Constructor(cn, constructor, ipArgs)); } else if (ip.instance != null) { InjectionPlanProto.Instance ins = ip.instance; object instance = Parse(ip.name, ins.value); return(new CsInstance(ch.GetNode(ip.name), instance)); } else if (ip.subplan != null) { InjectionPlanProto.Subplan subplan = ip.subplan; InjectionPlanProto.InjectionPlan[] protoBufPlans = subplan.plans.ToArray(); InjectionPlan[] subPlans = new InjectionPlan[protoBufPlans.Length]; for (int i = 0; i < protoBufPlans.Length; i++) { subPlans[i] = (InjectionPlan)Deserialize(ch, protoBufPlans[i]); } INode n = ch.GetNode(fullName); return(new Subplan(n, subPlans)); } else { throw new IllegalStateException("Encountered unknown type of injection plan: " + ip); } }
/// <summary> /// This program generates class hierarchy bin file for the list of dlls, plus a defalut list /// The default list include: ITask, StreamTask1, HelloTask and ShellTask, please remove if not needed /// </summary> /// <param name="args"> additional dlls needed to build class hierarchy </param> public static void Main(string[] args) { const string DllSubfix = ".dll"; const string ClassHierarchyBinFileName = "task.bin"; List <string> taskDlls = new List <string>(); foreach (string arg in args) { string assemblyName = arg; if (!arg.EndsWith(DllSubfix, StringComparison.OrdinalIgnoreCase)) { assemblyName += DllSubfix; } if (!File.Exists(assemblyName)) { throw new ArgumentException(string.Format(CultureInfo.InvariantCulture, "invalid argument: assembly {0} cannot be found", assemblyName)); } taskDlls.Add(arg); } taskDlls.Add(GetAssemblyName(typeof(ITask))); taskDlls.Add(GetAssemblyName(typeof(HelloTask))); taskDlls.Add(GetAssemblyName(typeof(ShellTask))); taskDlls.Add(GetAssemblyName(typeof(StreamTask1))); IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(taskDlls.ToArray()); // the following is verification only // to verify that a class indeeded has been added to the class hierarchy, check the class name IClassNode streamTaskClassNode = (IClassNode)ns.GetNode(typeof(StreamTask1).AssemblyQualifiedName); IClassNode helloTaskClassNode = (IClassNode)ns.GetNode(typeof(HelloTask).AssemblyQualifiedName); IClassNode shellTaskClassNode = (IClassNode)ns.GetNode(typeof(ShellTask).AssemblyQualifiedName); ProtocolBufferClassHierarchy.Serialize(ClassHierarchyBinFileName, ns); IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize(ClassHierarchyBinFileName); IClassNode retrievedStreamTaskClassNode = (IClassNode)ch.GetNode(typeof(StreamTask1).AssemblyQualifiedName); IClassNode retrievedHelloTaskClassNode = (IClassNode)ch.GetNode(typeof(HelloTask).AssemblyQualifiedName); IClassNode retrievedShellTaskClassNode = (IClassNode)ch.GetNode(typeof(ShellTask).AssemblyQualifiedName); if (!streamTaskClassNode.GetFullName().Equals(retrievedStreamTaskClassNode.GetFullName()) || !helloTaskClassNode.GetFullName().Equals(retrievedHelloTaskClassNode.GetFullName()) || !shellTaskClassNode.GetFullName().Equals(retrievedShellTaskClassNode.GetFullName())) { Console.WriteLine("Node deseriliazed is not equal"); } else { Console.WriteLine(string.Format(CultureInfo.InvariantCulture, "Class hierarchy written to [{0}].", Directory.GetCurrentDirectory())); } }
protected ConfigurationBuilderImpl(string[] assemblies, IConfiguration[] confs, Type[] parsers) { this.ClassHierarchy = TangFactory.GetTang().GetDefaultClassHierarchy(assemblies, parsers); foreach (IConfiguration tc in confs) { if (tc == null) { throw new ArgumentNullException("One of specified configurations is null"); } AddConfiguration((ConfigurationImpl)tc); } }
public static InjectionPlan Deserialize(IClassHierarchy ch, InjectionPlanProto.InjectionPlan ip) { string fullName = ip.name; if (ip.constructor != null) { InjectionPlanProto.Constructor cons = ip.constructor; IClassNode cn = (IClassNode) ch.GetNode(fullName); InjectionPlanProto.InjectionPlan[] protoBufArgs = cons.args.ToArray(); INode[] cnArgs = new INode[protoBufArgs.Length]; for (int i = 0; i < protoBufArgs.Length; i++) { cnArgs[i] = (INode) ch.GetNode(protoBufArgs[i].name); } InjectionPlan[] ipArgs = new InjectionPlan[protoBufArgs.Length]; for (int i = 0; i < protoBufArgs.Length; i++) { ipArgs[i] = (InjectionPlan) Deserialize(ch, protoBufArgs[i]); } IConstructorDef constructor = cn.GetConstructorDef(cnArgs); return new Constructor(cn, constructor, ipArgs); } else if (ip.instance != null) { InjectionPlanProto.Instance ins = ip.instance; object instance = Parse(ip.name, ins.value); return new CsInstance(ch.GetNode(ip.name), instance); } else if (ip.subplan != null) { InjectionPlanProto.Subplan subplan = ip.subplan; InjectionPlanProto.InjectionPlan[] protoBufPlans = subplan.plans.ToArray(); InjectionPlan[] subPlans = new InjectionPlan[protoBufPlans.Length]; for (int i = 0; i < protoBufPlans.Length; i++) { subPlans[i] = (InjectionPlan) Deserialize(ch, protoBufPlans[i]); } INode n = ch.GetNode(fullName); return new Subplan(n, subPlans); } else { throw new IllegalStateException("Encountered unknown type of injection plan: " + ip); } }
public IClassHierarchy Merge(IClassHierarchy ch) { if (this == ch) { return(this); } if (!(ch is ProtocolBufferClassHierarchy)) { Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new NotSupportedException( "Cannot merge ExternalClassHierarchies yet!"), LOGGER); } ProtocolBufferClassHierarchy pch = (ProtocolBufferClassHierarchy)ch; foreach (var pair in pch.lookupTable) { if (!this.lookupTable.ContainsKey(pair.Key)) { this.lookupTable.Add(pair); } } foreach (INode n in ch.GetNamespace().GetChildren()) { if (!rootNode.Contains(n.GetFullName())) { if (n is INamedParameterNode) { INamedParameterNode np = (INamedParameterNode)n; new NamedParameterNodeImpl(this.rootNode, np.GetName(), np.GetFullName(), np.GetFullArgName(), np.GetSimpleArgName(), np.IsSet(), np.IsList(), np.GetDocumentation(), np.GetShortName(), np.GetDefaultInstanceAsStrings().ToArray()); } else if (n is IClassNode) { IClassNode cn = (IClassNode)n; new ClassNodeImpl(rootNode, cn.GetName(), cn.GetFullName(), cn.IsUnit(), cn.IsInjectionCandidate(), cn.IsExternalConstructor(), cn.GetInjectableConstructors(), cn.GetAllConstructors(), cn.GetDefaultImplementation()); } } } return(this); }
/// <summary> /// Serialize a ClassHierarchy into a file /// </summary> /// <param name="c"></param> /// <param name="fileName"></param> public void ToFile(IClassHierarchy c, string fileName) { var avronNodeData = ToAvroNode(c); using (var buffer = new MemoryStream()) { using (var w = AvroContainer.CreateWriter<AvroNode>(buffer, Codec.Null)) { using (var writer = new SequentialWriter<AvroNode>(w, 24)) { writer.Write(avronNodeData); } } if (!WriteFile(buffer, fileName)) { var e = new ApplicationException("Error during file operation. Quitting method: " + fileName); Utilities.Diagnostics.Exceptions.Throw(e, LOGGER); } } }
public IClassHierarchy Merge(IClassHierarchy ch) { if (this.assemblies.Count == 0) { return ch; } return ch;//TODO }
public static Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan DeSerialize(string fileName, IClassHierarchy ch) { Org.Apache.REEF.Tang.Protobuf.InjectionPlan protoPlan; using (var file = File.OpenRead(fileName)) { protoPlan = Serializer.Deserialize<Org.Apache.REEF.Tang.Protobuf.InjectionPlan>(file); } return Deserialize(ch, protoPlan); }
public IConfiguration FromFile(string fileName, IClassHierarchy classHierarchy) { AvroConfiguration avroConf = AvroDeserializeFromFile(fileName); return FromAvro(avroConf, classHierarchy); }
public IConfiguration FromString(string josonString, IClassHierarchy ch) { AvroConfiguration avroConf = JsonConvert.DeserializeObject<AvroConfiguration>(josonString); return FromAvro(avroConf, ch); }
protected ConfigurationBuilderImpl() { this.ClassHierarchy = TangFactory.GetTang().GetDefaultClassHierarchy(); }
public ConfigurationBuilderImpl(IClassHierarchy classHierarchy) { this.ClassHierarchy = classHierarchy; }
/// <summary> /// Merge two Class Hierarchy /// </summary> /// <param name="ch"></param> /// <returns></returns> public IClassHierarchy Merge(IClassHierarchy ch) { if (this == ch) { return this; } if (!(ch is AvroClassHierarchy)) { Utilities.Diagnostics.Exceptions.Throw(new NotSupportedException( "Cannot merge ExternalClassHierarchies yet!"), LOGGER); } AvroClassHierarchy ach = (AvroClassHierarchy)ch; foreach (var pair in ach._lookupTable) { if (!this._lookupTable.ContainsKey(pair.Key)) { this._lookupTable.Add(pair); } } foreach (INode n in ch.GetNamespace().GetChildren()) { if (!_rootNode.Contains(n.GetFullName())) { if (n is INamedParameterNode) { INamedParameterNode np = (INamedParameterNode)n; new NamedParameterNodeImpl(this._rootNode, np.GetName(), np.GetFullName(), np.GetFullArgName(), np.GetSimpleArgName(), np.IsSet(), np.IsList(), np.GetDocumentation(), np.GetShortName(), np.GetDefaultInstanceAsStrings().ToArray()); } else if (n is IClassNode) { IClassNode cn = (IClassNode)n; new ClassNodeImpl(_rootNode, cn.GetName(), cn.GetFullName(), cn.IsUnit(), cn.IsInjectionCandidate(), cn.IsExternalConstructor(), cn.GetInjectableConstructors(), cn.GetAllConstructors(), cn.GetDefaultImplementation()); } } } return this; }
public static Node Serialize(IClassHierarchy classHierarchy) { return SerializeNode(classHierarchy.GetNamespace()); }
public IClassHierarchy Merge(IClassHierarchy ch) { if (this == ch) { return this; } if (!(ch is ClassHierarchyImpl)) { Utilities.Diagnostics.Exceptions.Throw(new NotSupportedException("Can't merge java and non-java class hierarchies yet!"), LOGGER); } if (this.assemblies.Count == 0) { return ch; } lock (_mergeLock) { ClassHierarchyImpl chi = (ClassHierarchyImpl)ch; MonotonicHashSet<string> otherJars = new MonotonicHashSet<string>(); otherJars.AddAll(chi.assemblies); MonotonicHashSet<string> myJars = new MonotonicHashSet<string>(); myJars.AddAll(this.assemblies); if (myJars.ContainsAll(otherJars)) { return this; } if (otherJars.ContainsAll(myJars)) { return ch; } myJars.Union(otherJars); return new ClassHierarchyImpl(myJars.ToArray()); } }
public IConfiguration FromAvro(AvroConfiguration avroConfiguration, IClassHierarchy classHierarchy) { IConfigurationBuilder cb = TangFactory.GetTang().NewConfigurationBuilder(classHierarchy); return AddFromAvro(cb, avroConfiguration); }
public static Org.Apache.REEF.Tang.Protobuf.Node Serialize(IClassHierarchy classHierarchy) { return SerializeNode(classHierarchy.GetNamespace()); }
/// <summary> /// erialize a ClassHierarchy into a byte array /// </summary> /// <param name="c"></param> /// <returns></returns> public byte[] ToByteArray(IClassHierarchy c) { AvroNode obj = ToAvroNode(c); return AvroSerialize(obj); }
/// <summary> /// Serialize a ClassHierarchy into a Json string /// </summary> /// <param name="c"></param> /// <returns></returns> public string ToString(IClassHierarchy c) { AvroNode obj = ToAvroNode(c); string s = JsonConvert.SerializeObject(obj, Formatting.Indented); return s; }
/// <summary> /// Serialize a ClassHierarchy into AvroNode object /// </summary> /// <param name="ch"></param> /// <returns></returns> public AvroNode ToAvroNode(IClassHierarchy ch) { return NewAvroNode(ch.GetNamespace()); }
private void AddConfiguration(IClassHierarchy ns, ConfigurationBuilderImpl builder) { this.ClassHierarchy = this.ClassHierarchy.Merge(ns); if (ClassHierarchy is ClassHierarchyImpl || builder.ClassHierarchy is ClassHierarchyImpl) { if (ClassHierarchy is ClassHierarchyImpl && builder.ClassHierarchy is ClassHierarchyImpl) { ((ClassHierarchyImpl)ClassHierarchy).Parameterparser.MergeIn(((ClassHierarchyImpl)builder.ClassHierarchy).Parameterparser); } else { Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ArgumentException("Attempt to merge Java and non-Java class hierarchy! Not supported."), LOGGER); } } foreach (IClassNode cn in builder.BoundImpls.Keys) { IClassNode n = null; builder.BoundImpls.TryGetValue(cn, out n); if (n != null) { Bind(cn.GetFullName(), n.GetFullName()); } } foreach (IClassNode cn in builder.BoundConstructors.Keys) { IClassNode n = null; builder.BoundConstructors.TryGetValue(cn, out n); if (n != null) { Bind(cn.GetFullName(), n.GetFullName()); } } // The namedParameters set contains the strings that can be used to // instantiate new // named parameter instances. Create new ones where we can. foreach (INamedParameterNode np in builder.NamedParameters.Keys) { string v = null; builder.NamedParameters.TryGetValue(np, out v); Bind(np.GetFullName(), v); } foreach (IClassNode cn in builder.LegacyConstructors.Keys) { IConstructorDef cd = null; builder.LegacyConstructors.TryGetValue(cn, out cd); RegisterLegacyConstructor(cn, cd.GetArgs()); } foreach (KeyValuePair<INamedParameterNode, object> e in builder.BoundSetEntries) { string name = ((INamedParameterNode)e.Key).GetFullName(); if (e.Value is INode) { BindSetEntry(name, (INode)e.Value); } else if (e.Value is string) { BindSetEntry(name, (string)e.Value); } else { var ex = new IllegalStateException(string.Format(CultureInfo.CurrentCulture, "The value {0} set to the named parameter {1} is illegel.", e.Value, name)); Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER); } } foreach (var p in builder.BoundLists) { BoundLists.Add(p.Key, p.Value); } }
public IConfigurationBuilder NewConfigurationBuilder(IClassHierarchy classHierarchy) { return new ConfigurationBuilderImpl(classHierarchy); }
public static void ClassSetup(TestContext context) { ns = TangFactory.GetTang().GetClassHierarchy(new string[] {file, file2, file3}); //ns = new ClassHierarchyImpl(@"Com.Microsoft.Tang.Examples.dll"); }
public static Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan Deserialize(IClassHierarchy ch, Org.Apache.REEF.Tang.Protobuf.InjectionPlan ip) { string fullName = ip.name; if (ip.constructor != null) { Org.Apache.REEF.Tang.Protobuf.Constructor cons = ip.constructor; IClassNode cn = (IClassNode) ch.GetNode(fullName); Org.Apache.REEF.Tang.Protobuf.InjectionPlan[] protoBufArgs = cons.args.ToArray(); IClassNode[] cnArgs = new IClassNode[protoBufArgs.Length]; for (int i = 0; i < protoBufArgs.Length; i++) { INode no = ch.GetNode(protoBufArgs[i].name); if (no is IClassNode) { cnArgs[i] = (IClassNode)no; } else if (no is INamedParameterNode) { INamedParameterNode np = (INamedParameterNode)no; cnArgs[i] = (IClassNode)ch.GetNode(np.GetFullArgName()); } } Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan[] ipArgs = new Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan[protoBufArgs.Length]; for (int i = 0; i < protoBufArgs.Length; i++) { ipArgs[i] = (Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan)Deserialize(ch, protoBufArgs[i]); } IConstructorDef constructor = cn.GetConstructorDef(cnArgs); return new Org.Apache.REEF.Tang.Implementations.InjectionPlan.Constructor(cn, constructor, ipArgs); } if (ip.instance != null) { Org.Apache.REEF.Tang.Protobuf.Instance ins = ip.instance; object instance = Parse(ip.name, ins.value); return new CsInstance(ch.GetNode(ip.name), instance); } if (ip.subplan != null) { Org.Apache.REEF.Tang.Protobuf.Subplan subplan = ip.subplan; Org.Apache.REEF.Tang.Protobuf.InjectionPlan[] protoBufPlans = subplan.plans.ToArray(); Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan[] subPlans = new Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan[protoBufPlans.Length]; for (int i = 0; i < protoBufPlans.Length; i++) { subPlans[i] = (Org.Apache.REEF.Tang.Implementations.InjectionPlan.InjectionPlan)Deserialize(ch, protoBufPlans[i]); } INode n = ch.GetNode(fullName); return new Org.Apache.REEF.Tang.Implementations.InjectionPlan.Subplan(n, subPlans); } Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Encountered unknown type of InjectionPlan: " + ip), LOGGER); return null; }