public ActionResult GetNodes(string node)
        {
            if (!string.IsNullOrEmpty(node))
            {
                NodeCollection nodes = new NodeCollection();
                SiteMapNode siteMapNode = SiteMap.Provider.FindSiteMapNodeFromKey(node);

                if (siteMapNode == null)
                {
                    return this.Store(nodes);
                }

                SiteMapNodeCollection children = siteMapNode.ChildNodes;

                if (children != null && children.Count > 0)
                {
                    foreach (SiteMapNode mapNode in siteMapNode.ChildNodes)
                    {
                        nodes.Add(NodeHelper.CreateNodeWithOutChildren(mapNode));
                    }
                }

                return this.Store(nodes);
            }

            return new HttpStatusCodeResult(500);
        }

 public SolverValidator(Solver solver, NodeCollection nodes, Node root, IPositionLookupTable<Node> transpositionTable)
 {
     this.solver = solver;
     this.nodes = nodes;
     this.root = root;
     this.transpositionTable = transpositionTable;
 }

        public static NodeCollection GetExamplesNodes()
        {
            var nodes = new NodeCollection();
            string path = HttpContext.Current.Server.MapPath(ExamplesModel.ExamplesRoot);

            return ExamplesModel.BuildAreasLevel();
        }

        public PPPragmaNode(IdentifierExpression identifier, NodeCollection<ConstantExpression> value, PragmaAction action)
            : base(identifier.RelatedToken)
		{
			this.identifier = identifier;
            this.value = value;
            this.Action = action;
		}

		public CompilationUnitNode(): base(new Token( TokenID.Invalid, 0, 0) )
		{
			this.globalAttributes = new NodeCollection<AttributeNode>();
            this.namespaces = new NodeCollection<NamespaceNode>();

            this.defaultNamespace = new NamespaceNode(RelatedToken);
		}

 public ForStatement(Token relatedToken)
     : base(relatedToken)
 {
     _blockStatement = new BlockStatement(relatedToken);
     _init = new NodeCollection<ExpressionNode>();
     _inc = new NodeCollection<ExpressionNode>();
 }

    public CompilationUnitNode()
      : base(new Token(TokenID.Invalid, 0, 0))
    {
      namespaces = new NodeCollection<NamespaceNode>();

      defaultNamespace = new NamespaceNode(RelatedToken);
    }

 private void EvalCollection(IContext context, NodeCollection<ExpressionNode> collection, Stream writer)
 {
     foreach (ExpressionNode node in collection)
     {
         node.Execute(context, writer);
     }
 }

        public string GetNodes(string node)
        {
            NodeCollection nodes = new NodeCollection(false);

            if (!string.IsNullOrEmpty(node))
            {
                for (int i = 1; i < 6; i++)
                {
                    Node asyncNode = new Node();
                    asyncNode.Text = node + i;
                    asyncNode.NodeID = node + i;
                    nodes.Add(asyncNode);
                }

                for (int i = 6; i < 11; i++)
                {
                    Node treeNode = new Node();
                    treeNode.Text = node + i;
                    treeNode.NodeID = node + i;
                    treeNode.Leaf = true;
                    nodes.Add(treeNode);
                }
            }

            return nodes.ToJson();
        }

        public static NodeCollection BuildFirstLevel()
        {
            string path = HttpContext.Current.Server.MapPath("~/Examples/");
            DirectoryInfo root = new DirectoryInfo(path);
            DirectoryInfo[] folders = root.GetDirectories();
            folders = UIHelpers.SortFolders(root, folders);

            NodeCollection nodes = new NodeCollection(false);

            foreach (DirectoryInfo folder in folders)
            {
                if ((folder.Attributes & FileAttributes.Hidden) == FileAttributes.Hidden ||
                    excludeList.Contains(folder.Name) || folder.Name.StartsWith("_"))
                {
                    continue;
                }

                ExampleConfig cfg = new ExampleConfig(folder.FullName + "\\config.xml", false);

                string iconCls = string.IsNullOrEmpty(cfg.IconCls) ? "" : cfg.IconCls;
                Node node = new Node();

                node.Text = UIHelpers.MarkNew(folder.FullName, folder.Name.Replace("_", " "));
                node.IconCls = iconCls;

                string url = UIHelpers.PhysicalToVirtual(folder.FullName + "/");
                node.NodeID = "e" + Math.Abs(url.ToLower().GetHashCode());

                nodes.Add(node);
            }

            return nodes;
        }

		public Scene()
		{
			_renderableNodes = new NodeCollection();
			_flatNodes = new NodeCollection();
			_environmentalNodes = new NodeCollection();

			AmbientColor = Color.FromArgb(0xff, 0x3f, 0x3f, 0x3f);
		}

        //PageHeader
        //PageFooter
        //InteractiveHeight
        //InteractiveWidth
        //EmbeddedImages
        //CodeModules
        //Classes
        //DataTransform

        public Report()
        {

            this.DataSources = new NodeCollection<DataSource>();
            this.DataSets = new NodeCollection<XDataSet>();
            this.EmbeddedImages = new NodeCollection<EmbeddedImage>();
            this.ReportParameters = new NodeCollection<ReportParameter>();
        }

 /// <summary>
 /// Get all the children recursive and flattens it into the given list.
 /// </summary>
 /// <param name="parent">The parent.</param>
 /// <param name="listToFill">The list to fill.</param>
 private void FlattenChildren(Node parent, ref NodeCollection listToFill)
 {
     listToFill.Add(parent);
     foreach (var child in parent.Children)
     {
         this.FlattenChildren(child, ref listToFill);
     }
 }

        public Element(string name, string text, params IAttribute[] attributes)
        {
            this._Name = name;
            this._Attributes = new AttributeCollection(attributes);
            this._Children = new NodeCollection(new Text(text));

            
        }

 public Table()
 {
     this.Header = new Header();
     this.Details = new Details();
     this.TableColumns = new NodeCollection<TableColumn>();
     this.TableGroups = new NodeCollection<TableGroup>(); 
     this.Style = new Style();
 }

        /// <summary>
        /// Makes a diffing engine for collections of elements.
        /// </summary>
        /// <param name="expected">The expected elements.</param>
        /// <param name="actual">The actual elements.</param>
        /// <param name="path">The current path of the parent node.</param>
        /// <param name="pathExpected">The path of the parent node of the parent collection.</param>
        /// <param name="options">Equality options.</param>
        /// <returns>The resulting diffing engine.</returns>
        public static IDiffEngine<NodeCollection> ForElements(NodeCollection expected, NodeCollection actual, IXmlPathStrict path, IXmlPathStrict pathExpected, Options options)
        {
            if ((options & Options.IgnoreElementsOrder) != 0)
            {
                return new DiffEngineForUnorderedElements(expected, actual, path, pathExpected, options);
            }

            return new DiffEngineForOrderedItems<NodeCollection, INode>(expected, actual, path, pathExpected, options, OrderedItemType.Element);
        }

        /// <summary>
        /// Reorder child nodes matching ChildNodeNames
        /// </summary>
        /// <param name="element">Element thats getting its children reordered</param>
        private void ReorderChildNodes(XElement element)
        {
            List<NodeCollection> nodeCollections = new List<NodeCollection>();

            var children = element.Nodes();

            // This indicates if last element matched ChildNodeNames
            bool inMatchingChildBlock = false;
            // This value changes each time a non matching ChildNodeName is reached ensuring that only sortable elements are reordered 
            int childBlockIndex = 0;

            NodeCollection currentNodeCollection = null;

            // Run through children
            foreach (var child in children)
            {
                if (currentNodeCollection == null)
                {
                    currentNodeCollection = new NodeCollection();
                    nodeCollections.Add(currentNodeCollection);
                }

                if (child.NodeType == XmlNodeType.Element)
                {
                    XElement childElement = (XElement)child;

                    var isMatchingChild = ChildNodeNames.Any(match => match.IsMatch(childElement.Name));
                    if (isMatchingChild == false || inMatchingChildBlock == false)
                    {
                        childBlockIndex++;
                        inMatchingChildBlock = isMatchingChild;
                    }

                    if (isMatchingChild)
                    {
                        currentNodeCollection.SortAttributeValues = SortByAttributes.Select(x => x.GetValue(childElement)).ToArray();
                    }

                    currentNodeCollection.BlockIndex = childBlockIndex;
                }

                currentNodeCollection.Nodes.Add(child);

                if (child.NodeType == XmlNodeType.Element)
                    currentNodeCollection = null;
            }

            if (currentNodeCollection != null)
                currentNodeCollection.BlockIndex = childBlockIndex + 1;

            // sort node list
            nodeCollections = nodeCollections.OrderBy(x => x).ToList();

            // replace the element's nodes
            element.ReplaceNodes(nodeCollections.SelectMany(nc => nc.Nodes));
        }

        /// <summary>
        /// Constructs a node instance.
        /// </summary>
        /// <param name="type">The type of the node.</param>
        /// <param name="index">The index of the node.</param>
        /// <param name="count">The number of elements at the same level.</param>
        /// <param name="children">The children nodes.</param>
        /// <exception cref="ArgumentNullException">Thrown if <paramref name="children"/> is null.</exception>
        protected NodeBase(NodeType type, int index, int count, IEnumerable<INode> children)
        {
            if (children == null)
                throw new ArgumentNullException("children");

            this.type = type;
            this.index = index;
            this.count = count;
            this.children = new NodeCollection(children);
        }

        /// <summary>Flattens the whole tree structure underneath me into a simple list.</summary>
        /// <returns>A enumerable list of flattened nodes.</returns>
        public IEnumerable<Node> FlattenChildrenRecursive()
        {
            // create the list to populate
            var list = new NodeCollection();

            // go recursive ! 
            this.FlattenChildren(this, ref list);

            return list;
        }

 public void Constructs_ok()
 {
     var mockMarkup1 = MockRepository.GenerateStub<INode>();
     var mockMarkup2 = MockRepository.GenerateStub<INode>();
     var mockMarkup3 = MockRepository.GenerateStub<INode>();
     var array = new[] { mockMarkup1, mockMarkup2, mockMarkup3 };
     var collection = new NodeCollection(array);
     Assert.Count(3, collection);
     Assert.AreElementsSame(array, collection);
 }