/// <summary> /// Creates a new EquivalenceNode containing the passed node and the specified nodes from the UnknownArguments list. /// The arguments are removed from the UnknownArguments list after being added to the EquivalenceNode. /// </summary> /// <param name="equivalentNode">The first node to add to the EquivalenceNode, i.e. the node that the unknown arguments are equivalent with.</param> /// <param name="equivalentUnknownArgs">The UnknownArguments to include in the equivalence.</param> /// <returns>An EquivalenceNode containing the passed node and the specified nodes from the UnknownArguments list.</returns> /// <exception cref="System.ArgumentNullException">equivalentNode is null.</exception> /// <exception cref="System.ArgumentNullException">equivalentUnknownArgs is null.</exception> public virtual EquivalenceNode CreateEquivalenceFromUnknownArguments(Node equivalentNode, IEnumerable<Node> equivalentUnknownArgs) { if(equivalentNode == null) { throw new ArgumentNullException("equivalentNode"); } if(equivalentUnknownArgs == null) { throw new ArgumentNullException("equivalentUnknownArgs"); } EquivalenceNode equivNode = new EquivalenceNode(equivalentNode); //add specified UnknownArguments to the equivalence foreach(var equivArg in equivalentUnknownArgs) { if(!this.UnknownArguments.Contains(equivArg)) { throw new InvalidOperationException(string.Format("Node is not present in the UnknownArguments collection: {0}", equivArg)); } equivNode.AddEquivalentNode(equivArg); } //remove equivalent arguments from the UnknownArguments list this.UnknownArguments.RemoveAll(n => equivalentUnknownArgs.Contains(n)); return equivNode; }
/// <summary> /// Creates a new ArgumentNode from the given parameters, and adds it to the SecondaryArguments list. /// </summary> /// <param name="argument">The node that is serving as the argument.</param> /// <param name="preposition">The preposition describing the argument's relation to the method.</param> public void AddSecondaryArgument(Node argument, WordNode preposition) { if(this.SecondaryArguments == null) { this.SecondaryArguments = new List<ArgumentNode>(); } ArgumentNode an = new ArgumentNode(argument, preposition); this.SecondaryArguments.Add(an); }
/// <summary> /// Creates a new EquivalenceNode containing the passed node and the specified nodes from the UnknownArguments list. /// The arguments are removed from the UnknownArguments list after being added to the EquivalenceNode. /// </summary> /// <param name="equivalentNode">The first node to add to the EquivalenceNode, i.e. the node that the unknown arguments are equivalent with.</param> /// <param name="equivalentUnknownArgs">An array of booleans indicating which unknown arguments to include in the equivalence. /// This array must be the same length as the UnknownArguments list. /// For each element in the array, a value of True means to include the corresponding unknown argument, False means to not include it.</param> /// <returns>An EquivalenceNode containing the passed node and the specified nodes from the UnknownArguments list.</returns> /// <exception cref="System.ArgumentNullException">equivalentNode is null.</exception> /// <exception cref="System.ArgumentException">The length of equivalentUnknownArgs is not the same as the UnknownArguments property of the MethodDeclarationNode.</exception> public virtual EquivalenceNode CreateEquivalenceFromUnknownArguments(Node equivalentNode, bool[] equivalentUnknownArgs) { if(equivalentNode == null) { throw new ArgumentNullException("equivalentNode"); } if(equivalentUnknownArgs.Length != UnknownArguments.Count) { throw new ArgumentException("Length of equivalentUnknownArgs array not equal to length of UnknownArguments", "equivalentUnknownArgs"); } //grab the specified UnknownArguments and put in a list List<Node> equivArgs = new List<Node>(); for(int argIndex = 0; argIndex < equivalentUnknownArgs.Length; argIndex++) { if(equivalentUnknownArgs[argIndex]) { equivArgs.Add(this.UnknownArguments[argIndex]); } } return CreateEquivalenceFromUnknownArguments(equivalentNode, equivArgs); }
/// <summary> /// Adds the given argument to the UnknownArguments list. /// </summary> /// <param name="argument">A Node corresponding to the argument to add.</param> public void AddUnknownArgument(Node argument) { if(this.UnknownArguments == null) { this.UnknownArguments = new List<Node>(); } this.UnknownArguments.Add(argument); }
/// <summary> /// Creates a new ArgumentNode. /// </summary> /// <param name="argument">The node being passed as an argument.</param> /// <param name="preposition">A prepostion describing the argument's relationship to its method.</param> public ArgumentNode(Node argument, WordNode preposition) { this.Argument = argument; this.Preposition = preposition; }
/// <summary> /// Adds a node to the list of equivalent nodes. /// </summary> /// <param name="n">The node to add.</param> public void AddEquivalentNode(Node n) { if(EquivalentNodes == null) { EquivalentNodes = new List<Node>(); } EquivalentNodes.Add(n); }
/// <summary> /// Creates a new EquivalenceNode. /// </summary> /// <param name="n">The initial node to add to the list of equivalent nodes.</param> public EquivalenceNode(Node n) { AddEquivalentNode(n); }
/// <summary> /// Parse <param name="nd"></param> to a string using in the summary /// </summary> /// <param name="nd"></param> /// <returns></returns> private string ParseSwumNodeToString(Node nd) { if (nd is EquivalenceNode) { var firstOrDefault = ((EquivalenceNode)nd).EquivalentNodes.FirstOrDefault(); if (firstOrDefault != null) return firstOrDefault.ToPlainString(); } //we could do more than that. return nd.ToPlainString(); }