ABB.Swum.Nodes.MethodDeclarationNode.CreateEquivalenceFromUnknownArguments C# (CSharp) Метод

CreateEquivalenceFromUnknownArguments() публичный метод

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.
equivalentNode is null. equivalentUnknownArgs is null.
public CreateEquivalenceFromUnknownArguments ( Node equivalentNode, IEnumerable equivalentUnknownArgs ) : EquivalenceNode
equivalentNode Node The first node to add to the EquivalenceNode, i.e. the node that the unknown arguments are equivalent with.
equivalentUnknownArgs IEnumerable The UnknownArguments to include in the equivalence.
Результат EquivalenceNode
        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;
        }

Same methods

MethodDeclarationNode::CreateEquivalenceFromUnknownArguments ( Node equivalentNode, bool equivalentUnknownArgs ) : EquivalenceNode

Usage Example

Пример #1
0
        /// <summary>
        /// Checks for semantic overlaps between parts of the given method's name and its UnknownArguments.
        /// If overlaps are found, appropriate EquivalenceNodes are created.
        /// </summary>
        /// <param name="mdn">The MethodDeclarationNode to check for overlaps.</param>
        /// <param name="checkDO">Indicates whether the Direct Object was taken from the method name, and therefore the Theme must be checked for overlap with UnknownArguments.</param>
        /// <param name="checkIO">Indicates whether the Indirect Object was taken from the method name, and therefore the SecondaryArguments must be checked for overlap with UnknownArguments.</param>
        private void CheckOverlap(MethodDeclarationNode mdn, bool checkDO, bool checkIO)
        {
            if (mdn.ParsedName[0].Text.ToLower() == "set") 
            { 
                return; //special case
            }

            PhraseNode theme = null;
            ArgumentNode arg = null;

            //get DO word from name
            string wordDO = "";
            if (checkDO) //theme is in the method name
            {
                theme = (PhraseNode)mdn.Theme;
                wordDO = theme.LastWord().Text;
            }

            //get IO word from name
            string wordIO = "";
            if (checkIO) //IO is in the method name
            {
                arg = mdn.SecondaryArguments[0];
                PhraseNode argn = (PhraseNode)arg.Argument;
                wordIO = argn.LastWord().Text;
                if (wordDO == wordIO)
                {
                    return; //no equivalence if multiple overlap
                }
            }

            //find overlap
            List<Node> unknownArgs = mdn.UnknownArguments;
            List<Node> DOOverlappingArgs = new List<Node>();
            List<Node> IOOverlappingArgs = new List<Node>();
            for (int i = 0; i < unknownArgs.Count; i++)
            {
                if (unknownArgs[i] is VariableDeclarationNode)
                {
                    VariableDeclarationNode var = (VariableDeclarationNode)unknownArgs[i];
                    PhraseNode name = var.ParsedName;
                    PhraseNode type = var.Type.ParsedName;
                    bool DOOverlaps = false;
                    bool IOOverlaps = false;

                    if (checkDO)
                    {
                        DOOverlaps = HasOverlap(name, wordDO) || HasOverlap(type, wordDO);
                        if (DOOverlaps) { DOOverlappingArgs.Add(unknownArgs[i]); }
                    }
                    if (checkIO)
                    {
                        IOOverlaps = HasOverlap(name, wordIO) || HasOverlap(type, wordIO);
                        if (IOOverlaps) { IOOverlappingArgs.Add(unknownArgs[i]); }
                    }

                    if (DOOverlaps && IOOverlaps)
                    {
                        return; //no equivalence if multiple overlap
                    }
                }
            }

            //Create overlap in SWUM
            if (DOOverlappingArgs.Count > 0)
            {
                EquivalenceNode en = mdn.CreateEquivalenceFromUnknownArguments(theme, DOOverlappingArgs);
                mdn.Theme = en; //reset theme in MethodDeclarationNode to new equivalence node
            }
            if (IOOverlappingArgs.Count > 0)
            {
                EquivalenceNode en = mdn.CreateEquivalenceFromUnknownArguments(arg.Argument, IOOverlappingArgs);
                arg.Argument = en; //reset mdn.SecondaryArguments to point to new equivalence node
            }
        }