public MibTreeNode AddChild(IEntity element)
{
MibTreeNode result = new MibTreeNode(this, element);
this.ChildNodes.Add(result);
return result;
}
private void UpdateTreeNodeTypes(MibTreeNode node)
{
node.UpdateNodeType();
foreach (MibTreeNode childNode in node.ChildNodes)
{
UpdateTreeNodeTypes(childNode);
}
}
public MibTreeNode AddChild(IEntity element)
{
MibTreeNode result = new MibTreeNode(this, element);
this.ChildNodes.Add(result);
return(result);
}
private void BuildTree(MibTreeNode node, IList<IEntity> entities)
{
int i = 0;
while (i < entities.Count)
{
if (entities[i].Parent == node.Entity.Name)
{
node.AddChild(entities[i]);
entities.RemoveAt(i);
}
else
{
i++;
}
}
foreach (MibTreeNode childNode in node.ChildNodes)
{
BuildTree(childNode, entities);
}
}
private void BuildTree(MibTreeNode node, IList <IEntity> entities)
{
int i = 0;
while (i < entities.Count)
{
if (entities[i].Parent == node.Entity.Name)
{
node.AddChild(entities[i]);
entities.RemoveAt(i);
}
else
{
i++;
}
}
foreach (MibTreeNode childNode in node.ChildNodes)
{
BuildTree(childNode, entities);
}
}
private void UpdateTreeNodeTypes(MibTreeNode node)
{
node.UpdateNodeType();
foreach (MibTreeNode childNode in node.ChildNodes)
{
UpdateTreeNodeTypes(childNode);
}
}
public MibTreeNode(MibTreeNode parent, IEntity entity)
{
_parent = parent;
_entity = entity;
}
private static SnmpTableNode GenerateSnmpTableNode(MibTreeNode mibTreeNode, SnmpTreeNode parentNode)
{
SnmpTableNode result = new SnmpTableNode(parentNode);
result.Name = mibTreeNode.Entity.Name;
result.Oid = mibTreeNode.Entity.Value;
// expect exactly one row entry
if ((mibTreeNode.ChildNodes.Count != 1) || ((mibTreeNode.ChildNodes[0].NodeType & MibTreeNodeType.TableRow) == 0) || (mibTreeNode.ChildNodes[0].Entity.Value != 1))
{
Console.WriteLine("Found table with unsupported properties! Table needs exactly one (fixed) TableRow with OID=1 ! (" + mibTreeNode.Entity.Name + ")");
return null;
}
MibTreeNode rowNode = mibTreeNode.ChildNodes[0];
ObjectType rot = rowNode.Entity as ObjectType;
if (rot != null)
{
if (!String.IsNullOrWhiteSpace(rot.Augments))
{
result.AugmentedTableRow = rot.Augments;
// the indeces from another table shall be used because this table is only an extension of it
rot = MibTypesResolver.ResolveDeclaration(rot.Module, rot.Augments) as ObjectType;
}
if (rot.Indices != null)
{
foreach (string index in rot.Indices)
{
ObjectType indexEntity = MibTypesResolver.ResolveDeclaration(rot.Module, index) as ObjectType;
if (indexEntity == null)
{
Console.WriteLine(String.Format("Could not resolve index '{0}' for table '{1}'! Table omitted!", index, result.Name));
return null;
}
result.IndexNodes.Add(GenerateSnmpScalarNode(indexEntity, parentNode, ignoreAccessibleFlag: true));
}
}
}
if (result.IndexNodes.Count == 0)
{
// a table cannot be used without index
Console.WriteLine("Found table without any index column ! (" + mibTreeNode.Entity.Name + ")");
return null;
}
// add child nodes
foreach (MibTreeNode cellNode in rowNode.ChildNodes)
{
SnmpScalarNode ssn = GenerateSnmpScalarNode(cellNode, parentNode);
if (ssn != null)
{
result.CellNodes.Add(ssn);
}
}
return result;
}
private static SnmpScalarNode GenerateSnmpScalarNode(MibTreeNode mibTreeNode, SnmpTreeNode parentNode, bool ignoreAccessibleFlag = false)
{
ObjectType ote = mibTreeNode.Entity as ObjectType;
if (ote != null)
{
return GenerateSnmpScalarNode(ote, parentNode, ignoreAccessibleFlag);
}
return null;
}
private static SnmpTreeNode GenerateSnmpTreeNode(MibTreeNode mibTreeNode, SnmpTreeNode parentNode)
{
SnmpTreeNode result = new SnmpTreeNode(parentNode);
result.Name = _alphaNumericRegex.Replace(mibTreeNode.Entity.Name, "").ToLowerInvariant();
result.Oid = mibTreeNode.Entity.Value;
result.FullOid = MibTypesResolver.ResolveOid(mibTreeNode.Entity).GetOidString();
return result;
}
private static void ProcessMibTreeNode(MibTreeNode mibTreeNode, SnmpTreeNode assignedSnmpNode)
{
foreach (MibTreeNode mtn in mibTreeNode.ChildNodes)
{
// in theory container nodes may also be scalars or tables at the same time (for now only process real containers)
if (mtn.NodeType == MibTreeNodeType.Container)
{
SnmpTreeNode snmpTreeNode = GenerateSnmpTreeNode(mtn, assignedSnmpNode);
assignedSnmpNode.ChildNodes.Add(snmpTreeNode);
ProcessMibTreeNode(mtn, snmpTreeNode);
}
else if ((mtn.NodeType & MibTreeNodeType.Scalar) != 0)
{
SnmpScalarNode snmpScalarNode = GenerateSnmpScalarNode(mtn, assignedSnmpNode);
if (snmpScalarNode != null)
{
assignedSnmpNode.ChildNodes.Add(snmpScalarNode);
}
}
else if ((mtn.NodeType & MibTreeNodeType.Table) != 0)
{
SnmpTableNode snmpTableNode = GenerateSnmpTableNode(mtn, assignedSnmpNode);
if (snmpTableNode != null)
{
assignedSnmpNode.ChildNodes.Add(snmpTableNode);
}
}
}
}
private void AddNode(MibTreeNode mibNode, TreeNodeCollection parentNodes)
{
int imgIndex = 5; //unknown
if ((mibNode.NodeType & MibTreeNodeType.Table) != 0)
{
imgIndex = 1;
}
else if ((mibNode.NodeType & MibTreeNodeType.TableRow) != 0)
{
imgIndex = 2;
}
else if ((mibNode.NodeType & MibTreeNodeType.TableCell) != 0)
{
imgIndex = 3;
}
else if ((mibNode.NodeType & MibTreeNodeType.Scalar) != 0)
{
imgIndex = 4;
}
else if ((mibNode.NodeType & MibTreeNodeType.Container) != 0)
{
imgIndex = 0;
}
TreeNode newNode = new TreeNode(mibNode.Entity.Name, imgIndex, imgIndex);
newNode.Tag = mibNode;
parentNodes.Add(newNode);
foreach (MibTreeNode child in mibNode.ChildNodes)
{
AddNode(child, newNode.Nodes);
}
}
public MibTreeNode(MibTreeNode parent, IEntity entity)
{
_parent = parent;
_entity = entity;
}
