protected virtual void AddChild(XElement data, string combinedId)
{
foreach (var org in Data.Elements("market"))
{
ChildNodes.Add(new MarketNode(org, combinedId, Level + 1));
}
}
internal BuildTimeScopeBlock AddChild()
{
BuildTimeScopeBlock block = new BuildTimeScopeBlock(this);
ChildNodes.Add(block);
return(block);
}
protected override void AddChild(XElement data, string combinedId)
{
foreach (var item in Data.Elements("country"))
{
ChildNodes.Add(new CountryNode(item, combinedId, Level + 1));
}
}
protected override void WriteInner(XmlWriter writer)
{
var nodeName = Data.Attribute("name").Value;
nodeName = ClearNonIdText(nodeName);
var nodeId = nodeName;
var combinedId = ParentId + "_" + nodeName;
ChildNodes.Add(new DivAdminTreeNode(combinedId, ParentId));
var input = new InputNode(nodeName, nodeId, ParentId);
ChildNodes.Add(input);
AddChild(Data, combinedId);
if (Data.Elements("users").Count() > 0)
{
foreach (var org in Data.Element("users").Elements("user"))
{
ChildNodes.Add(new UserNode(org, combinedId));
}
}
base.WriteInner(writer);
}
///--------------------------------------------------------------------------------
/// <summary>This method sets up the AST node and its children in the AST.</summary>
///
/// <param name="context">The parsing context.</param>
/// <param name="treeNode">The corresponding node in the parse tree.</param>
///--------------------------------------------------------------------------------
public override void Init(ParsingContext context, ParseTreeNode treeNode)
{
try
{
base.Init(context, treeNode);
foreach (ParseTreeNode node in treeNode.ChildNodes)
{
if (node.AstNode is ParameterNode)
{
Parameter = node.AstNode as ParameterNode;
ChildNodes.Add(node.AstNode as ParameterNode);
}
else
{
VariableName = node.FindTokenAndGetText();
}
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (System.Exception ex)
{
ThrowASTException(ex, true);
}
}
public void Initialize(WordNode parentNode, string characters)
{
if (string.IsNullOrEmpty(characters))
{
return;
}
var firstChar = characters[0];
var node = ChildNodes.Find(r => r.Character == firstChar);
if (node == null)
{
var newChild = new WordNode(characters.Remove(0, 1))
{
Character = firstChar
};
newChild.Parent = parentNode;
if (characters.Length == 1)
{
newChild.IsWord = true;
}
ChildNodes.Add(newChild);
}
else
{
node.Initialize(node, characters.Remove(0, 1));
}
}
public TreeNode AddChild(string text, string value)
{
var child = new TreeNode(text, value);
ChildNodes.Add(child);
return(child);
}
private void AddChild(NodeControl node)
{
if (!ChildNodes.Contains(node))
{
ChildNodes.Add(node);
}
}
protected override void WriteInner(System.Xml.XmlWriter writer)
{
var anchorContainer = new ComplexNode();
anchorContainer.Classes.Add("anchor");
var anchor = new ComplexNode("a");
anchor.Attributes.Add("href", "FileDownload/DownloadFile?fileName=" + _downloadFilePath);
var img = new SimpleNode("img", string.Empty);
img.Attributes.Add("src", _imagePath);
anchor.ChildNodes.Add(img);
var span = new SimpleNode("span", _downloadText);
anchor.ChildNodes.Add(span);
anchorContainer.ChildNodes.Add(anchor);
ChildNodes.Add(anchorContainer);
base.WriteInner(writer);
}
///--------------------------------------------------------------------------------
/// <summary>This method sets up the AST node and its children in the AST.</summary>
///
/// <param name="context">The parsing context.</param>
/// <param name="treeNode">The corresponding node in the parse tree.</param>
///--------------------------------------------------------------------------------
public override void Init(ParsingContext context, ParseTreeNode treeNode)
{
try
{
base.Init(context, treeNode);
Statements = new List <IStatementNode>();
foreach (ParseTreeNode node in treeNode.ChildNodes)
{
if (node.AstNode is ParameterNode)
{
DirectoryPath = node.AstNode as ParameterNode;
ChildNodes.Add(node.AstNode as ParameterNode);
}
else if (node.AstNode is LiteralValueNode)
{
Extensions = node.FindToken().ValueString;
}
else if (node.AstNode is StatementListNode)
{
(node.AstNode as StatementListNode).GetStatements(node, Statements, ChildNodes);
}
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (System.Exception ex)
{
ThrowASTException(ex, true);
}
}
/// <summary>
/// Adds a new element with a value as a child of the current node and returns it.
/// </summary>
/// <param name="name">The element name</param>
/// <param name="value">The text content of the new element</param>
/// <returns>The newly created child element</returns>
public TNode AddElement(string name, string value)
{
TNode childResult = new TNode(name, value);
ChildNodes.Add(childResult);
return(childResult);
}
public ExpandCollapseHyperLinkTableCell(string name = "td")
: base(name)
{
//Classes.Add("ExpandCollapseHyperLinkText");
ChildNodes.Add(ImgInnerNode);
ChildNodes.Add(HyperLinkInnerNode);
}
internal void AddNode(IList <string> routeTemplateFragments, Type requestHandler)
{
var headFragment = routeTemplateFragments.First();
var remainingTemplateFragments = routeTemplateFragments.Skip(1).ToList();
var childNode = FindChildNode(headFragment);
if (childNode != null)
{
if (remainingTemplateFragments.Any())
{
childNode.AddNode(remainingTemplateFragments, requestHandler);
}
else
{
childNode.RequestHandler = requestHandler;
}
}
else
{
var newChildNode = new RouteHandlerLookupNode(headFragment, remainingTemplateFragments, requestHandler);
ChildNodes.Add(newChildNode);
if (remainingTemplateFragments.Any())
{
newChildNode.AddNode(remainingTemplateFragments, requestHandler);
}
}
}
internal override void ReadChildElement(MSBuildXmlReader reader)
{
MSBuildObject ob = null;
switch (reader.LocalName)
{
case "ItemGroup": ob = new MSBuildItemGroup(); break;
case "PropertyGroup": ob = new MSBuildPropertyGroup(); break;
case "ImportGroup": ob = new MSBuildImportGroup(); break;
case "Import": ob = new MSBuildImport(); break;
case "Target": ob = new MSBuildTarget(); break;
case "Choose": ob = new MSBuildChoose(); break;
case "ProjectExtensions": ob = new MSBuildProjectExtensions(); break;
default: ob = new MSBuildXmlElement(); break;
}
if (ob != null)
{
ob.ParentNode = this;
ob.Read(reader);
ChildNodes = ChildNodes.Add(ob);
}
else
{
base.ReadChildElement(reader);
}
}
/// <summary>
/// Adds a new element as a child of the current node and returns it.
/// </summary>
/// <param name="name">The element name.</param>
/// <returns>The newly created child element</returns>
public XmlNode AddElement(string name)
{
XmlNode childResult = new XmlNode(name);
ChildNodes.Add(childResult);
return(childResult);
}
/// <summary>
/// Adds a new element with a value as a child of the current node and returns it.
/// The value will be output using a CDATA section.
/// </summary>
/// <param name="name">The element name</param>
/// <param name="value">The text content of the new element</param>
/// <returns>The newly created child element</returns>
public TNode AddElementWithCDATA(string name, string value)
{
TNode childResult = new TNode(name, EscapeInvalidXmlCharacters(value), true);
ChildNodes.Add(childResult);
return(childResult);
}
public MSBuildItemGroup AddNewItemGroup()
{
AssertCanModify();
var group = new MSBuildItemGroup();
MSBuildObject refNode = null;
var lastGroup = ItemGroups.LastOrDefault();
if (lastGroup != null)
{
refNode = lastGroup;
}
else
{
var g = PropertyGroups.LastOrDefault();
if (g != null)
{
refNode = g;
}
}
group.ParentNode = this;
if (refNode != null)
{
ChildNodes = ChildNodes.Insert(ChildNodes.IndexOf(refNode) + 1, group);
}
else
{
ChildNodes = ChildNodes.Add(group);
}
group.ResetIndent(true);
NotifyChanged();
return(group);
}
///--------------------------------------------------------------------------------
/// <summary>This method sets up the AST node and its children in the AST.</summary>
///
/// <param name="context">The parsing context.</param>
/// <param name="treeNode">The corresponding node in the parse tree.</param>
///--------------------------------------------------------------------------------
public override void Init(ParsingContext context, ParseTreeNode treeNode)
{
try
{
base.Init(context, treeNode);
foreach (ParseTreeNode node in treeNode.ChildNodes)
{
if (node.AstNode is ModelContextNode)
{
ModelContext = node.AstNode as ModelContextNode;
ChildNodes.Add(node.AstNode as ModelContextNode);
}
else if (node.AstNode is InClauseNode)
{
if (node.ChildNodes.Count > 0)
{
InClause = node.AstNode as InClauseNode;
ChildNodes.Add(node.AstNode as InClauseNode);
}
}
else if (node.AstNode is WhereClauseNode)
{
if (node.ChildNodes.Count > 0)
{
WhereClause = node.AstNode as WhereClauseNode;
ChildNodes.Add(node.AstNode as WhereClauseNode);
}
}
else if (node.AstNode is LimitClauseNode)
{
if (node.ChildNodes.Count > 0)
{
LimitClause = node.AstNode as LimitClauseNode;
ChildNodes.Add(node.AstNode as LimitClauseNode);
}
}
else if (node.AstNode is SortClauseNode)
{
if (node.ChildNodes.Count > 0)
{
SortClause = node.AstNode as SortClauseNode;
ChildNodes.Add(node.AstNode as SortClauseNode);
}
}
else
{
ForeachHelperName = node.FindTokenAndGetText();
}
}
}
catch (ApplicationAbortException)
{
throw;
}
catch (System.Exception ex)
{
ThrowASTException(ex, true);
}
}
/// <summary>
/// Calculate the node
/// </summary>
/// <param name="board">Current board state</param>
/// <param name="currentPosition">Position in board to set</param>
/// <param name="currentMove">Current move (either Computer or Human)</param>
/// <param name="depth">Current depth. Used for choosing earliest winning/losing move</param>
public MiniMaxNode(Board board, int currentPosition, Board.Cell currentMove, int depth)
{
// Create the child nodes list
this.ChildNodes = new List <MiniMaxNode>();
// Save the index to the cell we are updating. This way we always know what move
// this node corresponds to
this.UpdatedCellIndex = currentPosition;
// Set the cell to Computer/Human
board.Cells[this.UpdatedCellIndex] = currentMove;
if (board.GetState() == Board.State.ComputerWins)
{
// If Computer wins, give it a high score, but deduct the current depth
// (So that quick wins have higher scores than lengthy wins)
this.Score = 10 - depth;
}
else if (board.GetState() == Board.State.HumanWins)
{
// If Human wins, give it a low score, but add the current depth
// (So that quick loses have lower scores than lengthy loses)
this.Score = -10 + depth;
}
else if (board.GetState() == Board.State.Draw)
{
// If it's a draw, just set to neutral
this.Score = 0;
}
else
{
// Invert the player
var nextMove = currentMove == Board.Cell.Computer ? Board.Cell.Human : Board.Cell.Computer;
for (var i = 0; i < Board.BoardSize; i++)
{
// For each empty cell
if (board.Cells[i] == Board.Cell.Empty)
{
// Clone the board
var childBoard = board.Clone();
// Calculate child moves
var miniMaxNode = new MiniMaxNode(childBoard, i, nextMove, depth + 1);
ChildNodes.Add(miniMaxNode);
}
}
if (currentMove == Board.Cell.Computer)
{
// Since this isn't a terminal node, give the current node the best score
// amongst the child nodes..
this.Score = this.ChildNodes.OrderBy(n => n.Score).First().Score;
}
else
{
// ..or for Human moves, give it the worst score amongst the children
this.Score = this.ChildNodes.OrderBy(n => n.Score).Last().Score;
}
}
}
public void AddChild(TData data)
{
if (data != null)
{
var node = new TreeNode <TData>(data);
ChildNodes.Add(node);
}
}
protected Element this[INode child]
{
get
{
ChildNodes.Add(child);
return(this);
}
}
public void AppendChild(IHtmlNode node)
{
ChildNodes.Add(node);
if (node is IHtmlElement element)
{
ChildElements.Add(element);
}
}
internal override void ReadChildElement(MSBuildXmlReader reader)
{
var item = new MSBuildItem();
item.ParentNode = this;
item.Read(reader);
ChildNodes = ChildNodes.Add(item);
}
public new GenericElement this[INode child]
{
get
{
ChildNodes.Add(child);
return(this);
}
}
public void AppendChild(StreamGraphNode node)
{
if (!ChildNodes.Contains(node))
{
ChildNodes.Add(node);
node.ParentNodes.Add(this);
}
}
public virtual void SetParentInChildNode(IAstNode node)
{
if (ChildNodes == null)
{
ChildNodes = new List <IAstNode>();
}
ChildNodes.Add(node);
}
public void AddPropertyGroup(MSBuildPropertyGroup group, bool insertAtEnd = true, MSBuildObject beforeObject = null)
{
AssertCanModify();
if (group.ParentProject != null)
{
throw new InvalidOperationException("Group already belongs to a project");
}
group.ParentNode = this;
bool added = false;
if (beforeObject != null)
{
var index = ChildNodes.IndexOf(beforeObject);
if (index != -1)
{
ChildNodes = ChildNodes.Insert(index, group);
added = true;
}
}
if (!added)
{
if (insertAtEnd)
{
var last = ChildNodes.FindLastIndex(g => g is MSBuildPropertyGroup);
if (last != -1)
{
ChildNodes = ChildNodes.Insert(last + 1, group);
added = true;
}
}
else
{
var first = ChildNodes.FindIndex(g => g is MSBuildPropertyGroup);
if (first != -1)
{
ChildNodes = ChildNodes.Insert(first, group);
added = true;
}
}
if (!added)
{
var first = ChildNodes.FindIndex(g => g is MSBuildItemGroup);
if (first != -1)
{
ChildNodes = ChildNodes.Insert(first, group);
}
else
{
ChildNodes = ChildNodes.Add(group);
}
}
}
group.ResetIndent(true);
NotifyChanged();
}
public void AddRestRequestHandler(RestDigestibleUri uri, RestMethod method, RestRequestHandler handler)
{
if (uri.IsLastNode || this is WildCardUriRequestHandlerNode)
{
switch (method)
{
case RestMethod.GET:
if (HttpGetRequestHandler != null)
{
throw new Exception("Handler already defined");
}
HttpGetRequestHandler = handler;
return;
case RestMethod.POST:
if (HttpPostRequestHandler != null)
{
throw new Exception("Handler already defined");
}
HttpPostRequestHandler = handler;
return;
default:
throw new Exception("Unknown REST Method.");
}
}
uri.NextNode();
foreach (var childNode in ChildNodes)
{
if (childNode.MatchesUriPattern(uri) && ((childNode is ParameterUriRequestHandlerNode && uri.IsCurrentNodeParameterDefinition) ||
childNode is NamedUriRequestHandlerNode && !uri.IsCurrentNodeParameterDefinition))
{
childNode.AddRestRequestHandler(uri, method, handler);
return;
}
}
UriRequestHandlerNode newChildNode;
if (uri.IsCurrentNodeParameterDefinition)
{
newChildNode = new ParameterUriRequestHandlerNode(uri, method, handler);
}
else if (uri.IsWildCardNodeDefinition)
{
newChildNode = new WildCardUriRequestHandlerNode(uri, method, handler);
}
else
{
newChildNode = new NamedUriRequestHandlerNode(uri, method, handler);
}
ChildNodes.Add(newChildNode);
ChildNodes = ChildNodes.OrderBy(n => n.GetSearchPriority()).ToList();
}
/// <summary>
/// Метод добавления потомка к текущему узлу
/// </summary>
/// <param name="child">Потомок</param>
public FileViewModel AddChild(FileViewModel child)
{
if (child != null)
{
ChildNodes.Add(child);
}
return(this);
}
public void AddChild(XmlNode node)
{
ChildNodes.Add(node);
FirstChild = node;
if (node.NodeType == XmlNodeType.Element)
{
FirstElement = node;
}
}