/*public bool add(COOPType type) {
* if (contains(type)) return false;
*
* Node<COOPInterface> interfaceNode = Node.createInterfaceNode(type);
* foreach (COOPInterface parentInterface in type.parentInterfaces) {
* if (!contains(parentInterface)) add(parentInterface);
* interfaceNode.interfaces.Add(interfaceNodes[parentInterface]);
* }
*
* interfaceNodes.Add(type, interfaceNode);
* return true;
* }*/
public bool add(COOPAbstract @abstract)
{
if (@abstract == null)
{
return(false);
}
if (contains(@abstract))
{
return(false);
}
if (@abstract.parent != null && !contains(@abstract.parent))
{
add(@abstract.parent);
}
Node <COOPAbstract> parent = @abstract.parent != null ? abstractNodes[@abstract.parent] : null;
Node <COOPAbstract> created = Node.createAbstractNode(@abstract, parent);
/*foreach (COOPInterface parentInterface in @abstract.parentInterfaces) {
* if (!contains(parentInterface)) add(parentInterface);
* created.interfaces.Add(interfaceNodes[parentInterface]);
* }*/
abstractNodes.Add(@abstract, created);
return(true);
}
public bool contains(COOPAbstract @abstract)
{
if (@abstract == null)
{
return(false);
}
return(abstractNodes.ContainsKey(@abstract));
}
public COOPClass findNextAvailableParentClass(COOPAbstract a)
{
Node <COOPAbstract> parent = abstractNodes[a.parent];
if (parent == null)
{
return(null);
}
if (parent.isClass())
{
return(parent.type as COOPClass);
}
return(findNextAvailableParentClass(a.parent));
}
public COOPObject COOPCast <T>(T next) where T : COOPType
{
if (next is COOPAbstract)
{
COOPAbstract coopAbstract = next as COOPAbstract;
if (actualType.isParent(coopAbstract))
{
return(new COOPObject(next, actualType));
}
}
if (actualType.isParent(next))
{
return(new COOPObject(next, actualType));
}
return(null);
}
/*public static Node<COOPInterface> createInterfaceNode(COOPInterface @interface) {
* return new Node<COOPInterface>(@interface, null, new List<Node<COOPInterface>>());
* }*/
public static Node <COOPAbstract> createAbstractNode(COOPAbstract @abstract, Node <COOPAbstract> parent)
{
return(new Node <COOPAbstract>(@abstract, parent));
}
public COOPClass findNextAvailableParentClass(COOPAbstract a)
{
return(hierarchy.findNextAvailableParentClass(a));
}
