/// <summary>
 /// Constructs with the provided node ID, type and activation function ID.
 /// </summary>
 public NetworkNode(uint id, NodeType nodeType, int activationFnId)
 {
     _id = id;
     _nodeType = nodeType;
     _activationFnId = activationFnId;
     _auxState = null;
 }

 public void should_get_node(NodeType type)
 {
     var parent = new Node { NodeType = type };
     var child = new Node("hai");
     parent.Add(child, x => { });
     parent.GetNode("hai").ShouldEqual(child);
 }

	public void Update(NodeType nextType)
	{
		if (nextType == nodeType)
		{
			return;
		}

		switch(nextType)
		{
			case NodeType.Sequence:
				mInternalNode = new BirdNest.Nodes.Sequence();
				break;
			case NodeType.Selector:
				mInternalNode = new BirdNest.Nodes.Selector();
				break;
			case NodeType.Parallel:
				mInternalNode = new BirdNest.Nodes.Parallel();
				break;
			case NodeType.UsePlan:
				mInternalNode = new BirdNest.Nodes.UsePlanNode(this);
				break;
			default:
				mInternalNode = null;
				return;
		}
		nodeType = nextType;
	}

        public QuadNode(NodeType nodeType, int nodeSize, int nodeDepth, QuadNode parent, QuadTree parentTree, int positionIndex)
        {
            NodeType = nodeType;
            _nodeSize = nodeSize;
            _nodeDepth = nodeDepth;
            _positionIndex = positionIndex;

            _parent = parent;
            _parentTree = parentTree;

            //Add the 9 vertices
            AddVertices();

            Bounds = new BoundingBox(_parentTree.Vertices[VertexTopLeft.Index].Position,
                        _parentTree.Vertices[VertexBottomRight.Index].Position);

            if (nodeSize >= 4)
                AddChildren();

            //Make call to UpdateNeighbors from the parent node.
            //This will update all neighbors recursively for the
            //children as well.  This ensures all nodes are created
            //prior to updating neighbors.
            if (_nodeDepth == 1)
            {
                AddNeighbors();

                VertexTopLeft.Activated = true;
                VertexTopRight.Activated = true;
                VertexCenter.Activated = true;
                VertexBottomLeft.Activated = true;
                VertexBottomRight.Activated = true;

            }
        }

 /// <summary>
 /// Constructs a new node.
 /// </summary>
 internal Node(String name, NodeType type = NodeType.Element, NodeFlags flags = NodeFlags.None)
 {
     _name = name ?? String.Empty;
     _type = type;
     _children = new NodeList();
     _flags = flags;
 }

        public NodeGreetingMessageVerifier(NodeType localNodeType, NodeType expectedRemoteNodeType, params NodeType[] allowOtherRemoteNoteTypes)
        {
            _expectedRemoteNodeTypes = new HashSet<NodeType> { expectedRemoteNodeType };
            if (allowOtherRemoteNoteTypes != null) _expectedRemoteNodeTypes.UnionWith(allowOtherRemoteNoteTypes);

            _greetingMessage = new NodeGreetingMessage(localNodeType);
        }

 public XmlNodeInformation(string contentValue, int depth, CommonNamespaces commonNamespaces)
 {
     m_contentValue = contentValue;
     iDepth = depth;
     nodeType = NodeType.content;
     m_commonNamespaces = commonNamespaces;
 }

		public override INode Find(INodeResolver resolver, string uri, NodeType nodeType, FileSystemOptions options)
		{
			var address = LayeredNodeAddress.Parse(uri);

			if (address.Port >= 0 || address.UserName != "" || address.Password != "" || address.ServerName != "")
			{
				throw new MalformedUriException(uri, "Network & Authentication information not permitted");
			}

			if (nodeType.Is(typeof(IFile)))
			{
				var uri2 = address.InnerUri;

				if (StringUriUtils.ContainsQuery(uri2))
				{
					uri2 += "&shadow=true";
				}
				else
				{
					uri2 += "?shadow=true";
				}

				return resolver.Resolve(uri2, nodeType);
			}

			return resolver.Resolve(address.InnerUri);
		}

		protected override INode CreateNode(INodeAddress address, NodeType nodeType)
		{
			if (!address.IsRoot)
			{
				var parent = (IDirectory)this.Resolve(address.Parent, NodeType.Directory);

				if (parent is ImaginaryDirectory)
				{
					var retval = ((ImaginaryDirectory)parent).GetImaginaryChild(address.Name, nodeType);

					if (retval != null)
					{
						return retval;
					}
				}
			}

			if (nodeType == NodeType.Directory)
			{								
				return new ImaginaryDirectory(this, address);
			}
			else if (nodeType == NodeType.File)
			{
				return new ImaginaryFile(this, address);
			}

			throw new NotSupportedException(String.Format("{0}:{1}", address, nodeType));
		}

        /// <summary>
        /// Gets the type of the name to value collection from element for.
        /// </summary>
        /// <param name="mainDocumentPart">The main document part.</param>
        /// <param name="elementName">Name of the element.</param>
        /// <param name="forNodeType">Type of for node.</param>
        /// <returns></returns>
        public Dictionary<string, string> GetNameToValueCollectionFromElementForType(MainDocumentPart mainDocumentPart, string elementName, NodeType forNodeType)
        {
            Dictionary<string, string> nameToValueCollection = new Dictionary<string, string>();
            CustomXmlPart customXmlPart = this.customXmlPartCore.GetCustomXmlPart(mainDocumentPart);

            if (customXmlPart != null)
            {
                XElement element = this.customXmlPartCore.GetFirstElementFromCustomXmlPart(customXmlPart, elementName);

                if (element != null)
                {
                    if (forNodeType == NodeType.Element)
                    {
                        foreach (XElement elem in element.Elements())
                        {
                            nameToValueCollection.Add(elem.Name.LocalName, elem.Nodes().Where(node => node.NodeType == XmlNodeType.Element).FirstOrDefault().ToString());
                        }
                    }
                    else if (forNodeType == NodeType.Attribute)
                    {
                        foreach (XAttribute attr in element.Attributes())
                        {
                            nameToValueCollection.Add(attr.Name.LocalName, attr.Value);
                        }
                    }
                }
            }

            return nameToValueCollection;
        }

 public void AddGeoTreeNode(NodeType mapNodeType, List<GeoNodePara> clutterNodeParas)
 {
     if (clutterNodeParas.Count != 0)
     {
         List<GeoTreeNode> treeNode = new List<GeoTreeNode>();
         foreach (GeoNodePara para in clutterNodeParas)
         {
             GeoTreeNode item = this.GetGeoFolderNodeByName(this.m_DynamicNodeCollection, mapNodeType, para.FolderName);
             if (item == null)
             {
                 item = new GeoTreeNode(para.FolderName, LayerIDCreator.GetExclusiveID(), mapNodeType, CheckedState.Checked);
                 this.m_DynamicNodeCollection.Add(item);
                 treeNode.Add(item);
             }
             GeoTreeNode node2 = new GeoTreeNode(para.LayerName, para.LayerId, mapNodeType, CheckedState.Checked);
             foreach (KeyValuePair<int, string> pair in para.ClutterIdNameDict)
             {
                 int tag = (para.LayerId << 0x10) + ((short) pair.Key);
                 GeoTreeNode node3 = new GeoTreeNode(pair.Value, tag, mapNodeType, CheckedState.Checked);
                 node2.ChildrenNodes.Add(node3);
             }
             item.ChildrenNodes.Add(node2);
         }
         if (this.OnAddModelNodeEvent != null)
         {
             this.OnAddModelNodeEvent(treeNode);
         }
     }
 }

 //Constructor
 public NodeValue(string name, Object value, NodeType type)
     : base(name, Node.EmptyNodes)
 {
     _type = type;
     _value = value;
     _desc = "Value";
 }

        public BaseNode(string nodename)
        {
            NodeType = NodeType.Base;
            this.Text = nodename;
            this.ImageIndex = DataConvert.GetInt32(IconType.VsTemplates);
            this.SelectedImageIndex = DataConvert.GetInt32(IconType.VsTemplates);
		}

 IClassInfoGraphNode addClassInfoGraphNode(ObjectSpace objectSpace, IMemberInfo memberInfo, NodeType nodeType) {
     var classInfoGraphNode =(IClassInfoGraphNode)objectSpace.CreateObject(TypesInfo.Instance.ClassInfoGraphNodeType);
     classInfoGraphNode.Name = memberInfo.Name;
     classInfoGraphNode.TypeName = getSerializedType(memberInfo).Name;
     classInfoGraphNode.NodeType=nodeType;            
     return classInfoGraphNode;
 }

		public override IEnumerable<INode> DoGetChildren(NodeType nodeType, Predicate<INode> acceptNode)
		{
			foreach (string key in Environment.GetEnvironmentVariables().Keys)
			{
				yield return GetImaginaryChild(key, NodeType.File);
			}
		}

 public Node(string reference, GTASprite sprite, NodeType type)
 {
     Ref = reference;
     Direction = TreeDirection.Auto;
     Type = type;
     Sprite = sprite;
 }

 public Node GetChildByType(NodeType type)
 {
     if (Children != null)
         return Children.FirstOrDefault(c => c.Type == type);
     else
         return null;
 }

 protected internal BinaryFormula(NodeType nodeType, Formula left, IMethodDeclaration method, Formula right)
     : base(nodeType, left.Type)
 {
     Left = left;
     Method = method;
     Right = right;
 }

 public Node(NodeType nt,int sym,int freq,int order)
 {
     this.nt = nt;
     this.sym = sym;
     this.freq = freq;
     this.order = order;
 }

		public override INode Resolve(string uri, NodeType nodeType, AddressScope scope, FileSystemOptions options)
		{
			bool success;
			IFileSystem fileSystem;

			var address = LayeredNodeAddress.Parse(uri);
						
			lock (this.fileSystemCache)
			{
				success = this.fileSystemCache.TryGetValue(address.RootUri, out fileSystem);
			}

			if (!success)
			{
				var networkUri = String.Format("netvfs://{0}[" + uri + "]/", this.ipAddress);

				fileSystem = FileSystemManager.GetManager().ResolveDirectory(networkUri).FileSystem;

				lock (this.fileSystemCache)
				{
					this.fileSystemCache.Add(address.RootUri, fileSystem);
				}
			}

			return fileSystem.Resolve(address.PathAndQuery);
		}