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);
}
private static ClassHierarchyProto.Node SerializeNode(INode n)
{
IList <ClassHierarchyProto.Node> children = new List <ClassHierarchyProto.Node>();
foreach (INode child in n.GetChildren())
{
children.Add(SerializeNode(child));
}
if (n is IClassNode)
{
IClassNode cn = (IClassNode)n;
IList <IConstructorDef> injectable = cn.GetInjectableConstructors();
IList <IConstructorDef> all = cn.GetAllConstructors();
IList <IConstructorDef> others = new List <IConstructorDef>(all);
foreach (var c in injectable)
{
others.Remove(c);
}
IList <ClassHierarchyProto.ConstructorDef> injectableConstructors = new List <ClassHierarchyProto.ConstructorDef>();
foreach (IConstructorDef inj in injectable)
{
injectableConstructors.Add(SerializeConstructorDef(inj));
}
IList <ClassHierarchyProto.ConstructorDef> otherConstructors = new List <ClassHierarchyProto.ConstructorDef>();
foreach (IConstructorDef other in others)
{
otherConstructors.Add(SerializeConstructorDef(other));
}
List <string> implFullNames = new List <string>();
foreach (IClassNode impl in cn.GetKnownImplementations())
{
implFullNames.Add(impl.GetFullName());
}
return(NewClassNode(cn.GetName(), cn.GetFullName(),
cn.IsInjectionCandidate(), cn.IsExternalConstructor(), cn.IsUnit(),
injectableConstructors, otherConstructors, implFullNames, children));
}
else if (n is INamedParameterNode)
{
INamedParameterNode np = (INamedParameterNode)n;
return(NewNamedParameterNode(np.GetName(), np.GetFullName(),
np.GetSimpleArgName(), np.GetFullArgName(), np.IsSet(), np.GetDocumentation(),
np.GetShortName(), np.GetDefaultInstanceAsStrings(), children));
}
else if (n is IPackageNode)
{
return(NewPackageNode(n.GetName(), n.GetFullName(), children));
}
else
{
throw new IllegalStateException("Encountered unknown type of Node: " + n);
}
}
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);
}
private static Org.Apache.REEF.Tang.Protobuf.Node SerializeNode(INode n)
{
IList <Org.Apache.REEF.Tang.Protobuf.Node> children = new List <Org.Apache.REEF.Tang.Protobuf.Node>();
foreach (INode child in n.GetChildren())
{
children.Add(SerializeNode(child));
}
if (n is IClassNode)
{
IClassNode cn = (IClassNode)n;
IList <IConstructorDef> injectable = cn.GetInjectableConstructors();
IList <IConstructorDef> all = cn.GetAllConstructors();
IList <IConstructorDef> others = new List <IConstructorDef>(all);
foreach (var c in injectable)
{
others.Remove(c);
}
IList <Org.Apache.REEF.Tang.Protobuf.ConstructorDef> injectableConstructors = new List <Org.Apache.REEF.Tang.Protobuf.ConstructorDef>();
foreach (IConstructorDef inj in injectable)
{
injectableConstructors.Add(SerializeConstructorDef(inj));
}
IList <Org.Apache.REEF.Tang.Protobuf.ConstructorDef> otherConstructors = new List <Org.Apache.REEF.Tang.Protobuf.ConstructorDef>();
foreach (IConstructorDef other in others)
{
otherConstructors.Add(SerializeConstructorDef(other));
}
List <string> implFullNames = new List <string>();
foreach (IClassNode impl in cn.GetKnownImplementations())
{
implFullNames.Add(impl.GetFullName()); // we use class fully qualifed name
}
return(NewClassNode(cn.GetName(), cn.GetFullName(),
cn.IsInjectionCandidate(), cn.IsExternalConstructor(), cn.IsUnit(),
injectableConstructors, otherConstructors, implFullNames, children));
}
if (n is INamedParameterNode)
{
INamedParameterNode np = (INamedParameterNode)n;
return(NewNamedParameterNode(np.GetName(), np.GetFullName(),
np.GetSimpleArgName(), np.GetFullArgName(), np.IsSet(), np.IsList(), np.GetDocumentation(),
np.GetShortName(), np.GetDefaultInstanceAsStrings(), children, np.GetAlias(), np.GetAliasLanguage()));
}
if (n is IPackageNode)
{
return(NewPackageNode(n.GetName(), n.GetFullName(), children));
}
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new IllegalStateException("Encountered unknown type of Node: " + n), LOGGER);
return(null);
}
public void TestSimpleConstructors()
{
IClassNode cls = (IClassNode)ns.GetNode("Com.Microsoft.Tang.Examples.SimpleConstructors");
Assert.IsTrue(cls.GetChildren().Count == 0);
IList <IConstructorDef> def = cls.GetInjectableConstructors();
Assert.AreEqual(3, def.Count);
}
public void TestSimpleConstructors()
{
IClassNode cls = (IClassNode)ns.GetNode(typeof(SimpleConstructors).AssemblyQualifiedName);
Assert.True(cls.GetChildren().Count == 0);
IList <IConstructorDef> def = cls.GetInjectableConstructors();
Assert.Equal(3, def.Count);
}
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);
}
public void TestDeSerializeClassHierarchy()
{
IClassHierarchy ns = TangFactory.GetTang().GetClassHierarchy(new string[] { @"Com.Microsoft.Tang.Examples" });
IClassNode timerClassNode = (IClassNode)ns.GetNode("Com.Microsoft.Tang.Examples.Timer");
INode secondNode = (INode)ns.GetNode("Com.Microsoft.Tang.Examples.Timer+Seconds");
IClassNode SimpleConstructorsClassNode = (IClassNode)ns.GetNode("Com.Microsoft.Tang.Examples.SimpleConstructors");
ProtocolBufferClassHierarchy.Serialize("node.bin", ns);
IClassHierarchy ch = ProtocolBufferClassHierarchy.DeSerialize("node.bin");
IClassNode timerClassNode2 = (IClassNode)ch.GetNode("Com.Microsoft.Tang.Examples.Timer");
INode secondNode2 = ch.GetNode("Com.Microsoft.Tang.Examples.Timer+Seconds");
IClassNode SimpleConstructorsClassNode2 = (IClassNode)ch.GetNode("Com.Microsoft.Tang.Examples.SimpleConstructors");
Assert.AreEqual(timerClassNode.GetFullName(), timerClassNode2.GetFullName());
Assert.AreEqual(secondNode.GetFullName(), secondNode.GetFullName());
Assert.AreEqual(SimpleConstructorsClassNode.GetFullName(), SimpleConstructorsClassNode2.GetFullName());
Assert.IsTrue(SimpleConstructorsClassNode2.GetChildren().Count == 0);
IList <IConstructorDef> def = SimpleConstructorsClassNode2.GetInjectableConstructors();
Assert.AreEqual(3, def.Count);
}
public INode RegisterType(Type type)
{
if (ReflectionUtilities.IsAnonymousType(type))
{
// DevNote: Kinda hacky way to indicate the no-op case.
return(rootNode);
}
INode n = GetAlreadyBoundNode(type);
if (n != null)
{
return(n);
}
if (type.BaseType != null)
{
RegisterType(type.BaseType);
}
foreach (Type interf in type.GetInterfaces())
{
RegisterType(ReflectionUtilities.EnsureInterfaceType(interf));
}
Type enclosingClass = type.DeclaringType; // this.GetEnclosingClass(type);
if (enclosingClass != null)
{
RegisterType(enclosingClass);
}
INode node = RegisterClass(type);
foreach (Type inner in type.GetNestedTypes())
{
RegisterType(inner);
}
IClassNode classNode = node as ClassNodeImpl;
if (classNode != null)
{
foreach (IConstructorDef constructorDef in classNode.GetInjectableConstructors())
{
foreach (IConstructorArg constructorArg in constructorDef.GetArgs())
{
if (constructorArg.Gettype() == null)
{
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ArgumentException("not type in arg"), LOGGER);
}
RegisterType(constructorArg.Gettype()); // Gettype returns param's Type.fullname
if (constructorArg.GetNamedParameterName() != null)
{
var pn = RegisterType(constructorArg.GetNamedParameterName());
if (!(pn is INamedParameterNode))
{
string message = string.Format(CultureInfo.CurrentCulture,
"The class {0}, used in the constructor of {1}, should not be defined as a NamedParameter.",
constructorArg.GetNamedParameterName(),
constructorDef.GetClassName());
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(new ArgumentException(message), LOGGER);
}
INamedParameterNode np = (INamedParameterNode)RegisterType(constructorArg.GetNamedParameterName());
try
{
if (np.IsSet() || np.IsList())
{
// throw new NotImplementedException();
}
else
{
if (!ReflectionUtilities.IsCoercable(ClassForName(constructorArg.Gettype()), ClassForName(np.GetFullArgName())))
{
var e = new ClassHierarchyException(
"Named parameter type mismatch in " + classNode.GetFullName() + ". Constructor expects a "
+ constructorArg.Gettype() + " but " + np.GetName() + " is a "
+ np.GetFullArgName());
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(e, LOGGER);
}
}
}
catch (TypeLoadException e)
{
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Caught(e, Level.Error, LOGGER);
var ex = new ClassHierarchyException("Constructor refers to unknown class "
+ constructorArg.GetType(), e);
Org.Apache.REEF.Utilities.Diagnostics.Exceptions.Throw(ex, LOGGER);
}
}
}
}
}
else
{
INamedParameterNode npNode = node as INamedParameterNode;
if (npNode != null)
{
RegisterType(npNode.GetFullArgName());
}
}
return(node);
}
public INode RegisterType(Type type)
{
try
{
INode n = GetAlreadyBoundNode(type);
return(n);
}
catch (NameResolutionException e)
{
}
if (type.BaseType != null)
{
RegisterType(type.BaseType);
}
foreach (Type interf in type.GetInterfaces())
{
RegisterType(interf);
}
Type enclosingClass = this.GetIEnclosingClass(type);
if (enclosingClass != null)
{
RegisterType(enclosingClass);
}
INode node = RegisterClass(type);
foreach (Type inner in type.GetNestedTypes())
{
RegisterType(inner);
}
IClassNode classNode = node as ClassNodeImpl;
if (classNode != null)
{
foreach (IConstructorDef constructorDef in classNode.GetInjectableConstructors())
{
foreach (IConstructorArg constructorArg in constructorDef.GetArgs())
{
if (constructorArg.Gettype() == null)
{
throw new ArgumentException("not type in arg");
}
RegisterType(constructorArg.Gettype()); //Gettype returns param's Type.fullname
if (constructorArg.GetNamedParameterName() != null)
{
INamedParameterNode np = (INamedParameterNode)RegisterType(constructorArg.GetNamedParameterName());
if (np.IsSet())
{
throw new NotImplementedException();
}
else
{
//check is not isCoercable, then throw ClassHierarchyException
}
}
}
}
}
else
{
INamedParameterNode npNode = node as INamedParameterNode;
if (npNode != null)
{
RegisterType(npNode.GetFullArgName());
}
}
return(node);
}
