Esempio n. 1
0
        /// <summary>
        /// Gets the set of roles not filled. Numbers in the set correspond to the argument positions in the frame file for the
        /// current nominal predicate. Only valid for root nodes.
        /// </summary>
        /// <param name="considerNullElementNodes">Whether or not to consider null-element nodes when checking whether a role is filled</param>
        public Set <int> GetUnfilledRoles(bool considerNullElementNodes)
        {
            if (!IsRoot)
            {
                throw new Exception("Not valid for non-root nodes");
            }

            // check for a node that fills each role in the set
            Set <int> unfilledRoles = new Set <int>();

            foreach (Role role in RoleSet)
            {
                bool filled = false;
                NomBankNodeLabel.NodeType argType = (NomBankNodeLabel.NodeType)Enum.Parse(typeof(NomBankNodeLabel.NodeType), "Arg" + role.Number);
                foreach (NomBankNode node in GetDescendants(argType))
                {
                    if (!node.IsNullElement || considerNullElementNodes)
                    {
                        filled = true;
                        break;
                    }
                }

                if (!filled)
                {
                    unfilledRoles.Add(role.Number);
                }
            }

            return(unfilledRoles);
        }
Esempio n. 2
0
        /// <summary>
        /// Gets whether or not this node is of the given type
        /// </summary>
        /// <param name="type">Type to check for</param>
        /// <returns>True if node is of given type and false otherwise</returns>
        public bool HasType(NomBankNodeLabel.NodeType type)
        {
            foreach (NomBankNodeLabel label in _labels)
            {
                if (label.Type == type)
                {
                    return(true);
                }
            }

            return(false);
        }
Esempio n. 3
0
        /// <summary>
        /// Gets labels matching given type
        /// </summary>
        /// <param name="type">Type of label to get</param>
        /// <returns>Set of labels</returns>
        public Set <NomBankNodeLabel> GetLabels(NomBankNodeLabel.NodeType type)
        {
            Set <NomBankNodeLabel> labels = new Set <NomBankNodeLabel>();

            foreach (NomBankNodeLabel label in _labels)
            {
                if (label.Type == type)
                {
                    labels.Add(label);
                }
            }

            return(labels);
        }
Esempio n. 4
0
        /// <summary>
        /// Gets descendant nodes by their type
        /// </summary>
        /// <param name="type">Type of node to get</param>
        /// <returns>List of nodes of given type</returns>
        public List <NomBankNode> GetDescendants(NomBankNodeLabel.NodeType type)
        {
            List <NomBankNode> nodes = new List <NomBankNode>();

            foreach (NomBankNode n in Descendants)
            {
                if (n.HasType(type))
                {
                    nodes.Add(n);
                }
            }

            return(nodes);
        }
Esempio n. 5
0
        /// <summary>
        /// Removes labels of a given type
        /// </summary>
        /// <param name="type">Type of label to remove</param>
        public void RemoveLabels(NomBankNodeLabel.NodeType type)
        {
            List <NomBankNodeLabel> toRemove = new List <NomBankNodeLabel>();

            foreach (NomBankNodeLabel label in _labels)
            {
                if (label.Type == type)
                {
                    toRemove.Add(label);
                }
            }

            foreach (NomBankNodeLabel label in toRemove)
            {
                RemoveLabel(label);
            }
        }