--- /dev/null
+/* Copyright (c) 2012-2017 The ANTLR Project. All rights reserved.
+ * Use of this file is governed by the BSD 3-clause license that
+ * can be found in the LICENSE.txt file in the project root.
+ */
+
+#pragma once
+
+#include "antlr4-common.h"
+
+namespace antlr4 {
+namespace tree {
+namespace pattern {
+
+ /// Represents the result of matching a ParseTree against a tree pattern.
+ class ANTLR4CPP_PUBLIC ParseTreeMatch {
+ private:
+ /// This is the backing field for getTree().
+ ParseTree *_tree;
+
+ /// This is the backing field for getPattern().
+ const ParseTreePattern &_pattern;
+
+ /// This is the backing field for getLabels().
+ std::map<std::string, std::vector<ParseTree *>> _labels;
+
+ /// This is the backing field for getMismatchedNode().
+ ParseTree *_mismatchedNode;
+
+ public:
+ /// <summary>
+ /// Constructs a new instance of <seealso cref="ParseTreeMatch"/> from the specified
+ /// parse tree and pattern.
+ /// </summary>
+ /// <param name="tree"> The parse tree to match against the pattern. </param>
+ /// <param name="pattern"> The parse tree pattern. </param>
+ /// <param name="labels"> A mapping from label names to collections of
+ /// <seealso cref="ParseTree"/> objects located by the tree pattern matching process. </param>
+ /// <param name="mismatchedNode"> The first node which failed to match the tree
+ /// pattern during the matching process.
+ /// </param>
+ /// <exception cref="IllegalArgumentException"> if {@code tree} is {@code null} </exception>
+ /// <exception cref="IllegalArgumentException"> if {@code pattern} is {@code null} </exception>
+ /// <exception cref="IllegalArgumentException"> if {@code labels} is {@code null} </exception>
+ ParseTreeMatch(ParseTree *tree, ParseTreePattern const& pattern,
+ const std::map<std::string, std::vector<ParseTree *>> &labels, ParseTree *mismatchedNode);
+ ParseTreeMatch(ParseTreeMatch const&) = default;
+ virtual ~ParseTreeMatch();
+
+ /// <summary>
+ /// Get the last node associated with a specific {@code label}.
+ /// <p/>
+ /// For example, for pattern {@code <id:ID>}, {@code get("id")} returns the
+ /// node matched for that {@code ID}. If more than one node
+ /// matched the specified label, only the last is returned. If there is
+ /// no node associated with the label, this returns {@code null}.
+ /// <p/>
+ /// Pattern tags like {@code <ID>} and {@code <expr>} without labels are
+ /// considered to be labeled with {@code ID} and {@code expr}, respectively.
+ /// </summary>
+ /// <param name="labe"> The label to check.
+ /// </param>
+ /// <returns> The last <seealso cref="ParseTree"/> to match a tag with the specified
+ /// label, or {@code null} if no parse tree matched a tag with the label. </returns>
+ virtual ParseTree* get(const std::string &label);
+
+ /// <summary>
+ /// Return all nodes matching a rule or token tag with the specified label.
+ /// <p/>
+ /// If the {@code label} is the name of a parser rule or token in the
+ /// grammar, the resulting list will contain both the parse trees matching
+ /// rule or tags explicitly labeled with the label and the complete set of
+ /// parse trees matching the labeled and unlabeled tags in the pattern for
+ /// the parser rule or token. For example, if {@code label} is {@code "foo"},
+ /// the result will contain <em>all</em> of the following.
+ ///
+ /// <ul>
+ /// <li>Parse tree nodes matching tags of the form {@code <foo:anyRuleName>} and
+ /// {@code <foo:AnyTokenName>}.</li>
+ /// <li>Parse tree nodes matching tags of the form {@code <anyLabel:foo>}.</li>
+ /// <li>Parse tree nodes matching tags of the form {@code <foo>}.</li>
+ /// </ul>
+ /// </summary>
+ /// <param name="labe"> The label.
+ /// </param>
+ /// <returns> A collection of all <seealso cref="ParseTree"/> nodes matching tags with
+ /// the specified {@code label}. If no nodes matched the label, an empty list
+ /// is returned. </returns>
+ virtual std::vector<ParseTree *> getAll(const std::string &label);
+
+ /// <summary>
+ /// Return a mapping from label → [list of nodes].
+ /// <p/>
+ /// The map includes special entries corresponding to the names of rules and
+ /// tokens referenced in tags in the original pattern. For additional
+ /// information, see the description of <seealso cref="#getAll(String)"/>.
+ /// </summary>
+ /// <returns> A mapping from labels to parse tree nodes. If the parse tree
+ /// pattern did not contain any rule or token tags, this map will be empty. </returns>
+ virtual std::map<std::string, std::vector<ParseTree *>>& getLabels();
+
+ /// <summary>
+ /// Get the node at which we first detected a mismatch.
+ /// </summary>
+ /// <returns> the node at which we first detected a mismatch, or {@code null}
+ /// if the match was successful. </returns>
+ virtual ParseTree* getMismatchedNode();
+
+ /// <summary>
+ /// Gets a value indicating whether the match operation succeeded.
+ /// </summary>
+ /// <returns> {@code true} if the match operation succeeded; otherwise,
+ /// {@code false}. </returns>
+ virtual bool succeeded();
+
+ /// <summary>
+ /// Get the tree pattern we are matching against.
+ /// </summary>
+ /// <returns> The tree pattern we are matching against. </returns>
+ virtual const ParseTreePattern& getPattern();
+
+ /// <summary>
+ /// Get the parse tree we are trying to match to a pattern.
+ /// </summary>
+ /// <returns> The <seealso cref="ParseTree"/> we are trying to match to a pattern. </returns>
+ virtual ParseTree* getTree();
+
+ virtual std::string toString();
+ };
+
+} // namespace pattern
+} // namespace tree
+} // namespace antlr4
projects / toc / blobdiff