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 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 indices 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);
        }