fhirpath-rb 0.1.2 → 0.1.4

data/ext/fhir_path_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/xpath/XPathWildcardAnywhereElement.h

@@ -0,0 +1,23 @@
+/* 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 "XPathElement.h"
+
+namespace antlr4 {
+namespace tree {
+namespace xpath {
+
+  class ANTLR4CPP_PUBLIC XPathWildcardAnywhereElement : public XPathElement {
+  public:
+    XPathWildcardAnywhereElement();
+
+    virtual std::vector<ParseTree *> evaluate(ParseTree *t) override;
+  };
+
+} // namespace xpath
+} // namespace tree
+} // namespace antlr4

data/ext/fhir_path_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/xpath/XPathWildcardElement.cpp

@@ -0,0 +1,24 @@
+/* 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.
+ */
+
+#include "XPath.h"
+#include "tree/ParseTree.h"
+#include "tree/Trees.h"
+
+#include "XPathWildcardElement.h"
+
+using namespace antlr4::tree;
+using namespace antlr4::tree::xpath;
+
+XPathWildcardElement::XPathWildcardElement() : XPathElement(XPath::WILDCARD) {
+}
+
+std::vector<ParseTree *> XPathWildcardElement::evaluate(ParseTree *t) {
+  if (_invert) {
+    return {}; // !* is weird but valid (empty)
+  }
+
+  return t->children;
+}

data/ext/fhir_path_parser/antlr4-upstream/runtime/Cpp/runtime/src/tree/xpath/XPathWildcardElement.h

@@ -0,0 +1,23 @@
+/* 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 "XPathElement.h"
+
+namespace antlr4 {
+namespace tree {
+namespace xpath {
+
+  class ANTLR4CPP_PUBLIC XPathWildcardElement : public XPathElement {
+  public:
+    XPathWildcardElement();
+
+    virtual std::vector<ParseTree *> evaluate(ParseTree *t) override;
+  };
+
+} // namespace xpath
+} // namespace tree
+} // namespace antlr4

data/ext/fhir_path_parser/antlrgen/FHIRPathBaseListener.cpp

@@ -0,0 +1,7 @@
+
+// Generated from /home/runner/work/fhirpath-ruby/fhirpath-ruby/lib/fhirpath/parser/FHIRPath.g4 by ANTLR 4.10.1
+
+
+#include "FHIRPathBaseListener.h"
+
+

data/ext/fhir_path_parser/antlrgen/FHIRPathBaseListener.h

@@ -0,0 +1,149 @@
+
+// Generated from /home/runner/work/fhirpath-ruby/fhirpath-ruby/lib/fhirpath/parser/FHIRPath.g4 by ANTLR 4.10.1
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+#include "FHIRPathListener.h"
+
+
+/**
+ * This class provides an empty implementation of FHIRPathListener,
+ * which can be extended to create a listener which only needs to handle a subset
+ * of the available methods.
+ */
+class  FHIRPathBaseListener : public FHIRPathListener {
+public:
+
+  virtual void enterEntireExpression(FHIRPathParser::EntireExpressionContext * /*ctx*/) override { }
+  virtual void exitEntireExpression(FHIRPathParser::EntireExpressionContext * /*ctx*/) override { }
+
+  virtual void enterIndexerExpression(FHIRPathParser::IndexerExpressionContext * /*ctx*/) override { }
+  virtual void exitIndexerExpression(FHIRPathParser::IndexerExpressionContext * /*ctx*/) override { }
+
+  virtual void enterPolarityExpression(FHIRPathParser::PolarityExpressionContext * /*ctx*/) override { }
+  virtual void exitPolarityExpression(FHIRPathParser::PolarityExpressionContext * /*ctx*/) override { }
+
+  virtual void enterAdditiveExpression(FHIRPathParser::AdditiveExpressionContext * /*ctx*/) override { }
+  virtual void exitAdditiveExpression(FHIRPathParser::AdditiveExpressionContext * /*ctx*/) override { }
+
+  virtual void enterMultiplicativeExpression(FHIRPathParser::MultiplicativeExpressionContext * /*ctx*/) override { }
+  virtual void exitMultiplicativeExpression(FHIRPathParser::MultiplicativeExpressionContext * /*ctx*/) override { }
+
+  virtual void enterUnionExpression(FHIRPathParser::UnionExpressionContext * /*ctx*/) override { }
+  virtual void exitUnionExpression(FHIRPathParser::UnionExpressionContext * /*ctx*/) override { }
+
+  virtual void enterOrExpression(FHIRPathParser::OrExpressionContext * /*ctx*/) override { }
+  virtual void exitOrExpression(FHIRPathParser::OrExpressionContext * /*ctx*/) override { }
+
+  virtual void enterAndExpression(FHIRPathParser::AndExpressionContext * /*ctx*/) override { }
+  virtual void exitAndExpression(FHIRPathParser::AndExpressionContext * /*ctx*/) override { }
+
+  virtual void enterMembershipExpression(FHIRPathParser::MembershipExpressionContext * /*ctx*/) override { }
+  virtual void exitMembershipExpression(FHIRPathParser::MembershipExpressionContext * /*ctx*/) override { }
+
+  virtual void enterInequalityExpression(FHIRPathParser::InequalityExpressionContext * /*ctx*/) override { }
+  virtual void exitInequalityExpression(FHIRPathParser::InequalityExpressionContext * /*ctx*/) override { }
+
+  virtual void enterInvocationExpression(FHIRPathParser::InvocationExpressionContext * /*ctx*/) override { }
+  virtual void exitInvocationExpression(FHIRPathParser::InvocationExpressionContext * /*ctx*/) override { }
+
+  virtual void enterEqualityExpression(FHIRPathParser::EqualityExpressionContext * /*ctx*/) override { }
+  virtual void exitEqualityExpression(FHIRPathParser::EqualityExpressionContext * /*ctx*/) override { }
+
+  virtual void enterImpliesExpression(FHIRPathParser::ImpliesExpressionContext * /*ctx*/) override { }
+  virtual void exitImpliesExpression(FHIRPathParser::ImpliesExpressionContext * /*ctx*/) override { }
+
+  virtual void enterTermExpression(FHIRPathParser::TermExpressionContext * /*ctx*/) override { }
+  virtual void exitTermExpression(FHIRPathParser::TermExpressionContext * /*ctx*/) override { }
+
+  virtual void enterTypeExpression(FHIRPathParser::TypeExpressionContext * /*ctx*/) override { }
+  virtual void exitTypeExpression(FHIRPathParser::TypeExpressionContext * /*ctx*/) override { }
+
+  virtual void enterInvocationTerm(FHIRPathParser::InvocationTermContext * /*ctx*/) override { }
+  virtual void exitInvocationTerm(FHIRPathParser::InvocationTermContext * /*ctx*/) override { }
+
+  virtual void enterLiteralTerm(FHIRPathParser::LiteralTermContext * /*ctx*/) override { }
+  virtual void exitLiteralTerm(FHIRPathParser::LiteralTermContext * /*ctx*/) override { }
+
+  virtual void enterExternalConstantTerm(FHIRPathParser::ExternalConstantTermContext * /*ctx*/) override { }
+  virtual void exitExternalConstantTerm(FHIRPathParser::ExternalConstantTermContext * /*ctx*/) override { }
+
+  virtual void enterParenthesizedTerm(FHIRPathParser::ParenthesizedTermContext * /*ctx*/) override { }
+  virtual void exitParenthesizedTerm(FHIRPathParser::ParenthesizedTermContext * /*ctx*/) override { }
+
+  virtual void enterNullLiteral(FHIRPathParser::NullLiteralContext * /*ctx*/) override { }
+  virtual void exitNullLiteral(FHIRPathParser::NullLiteralContext * /*ctx*/) override { }
+
+  virtual void enterBooleanLiteral(FHIRPathParser::BooleanLiteralContext * /*ctx*/) override { }
+  virtual void exitBooleanLiteral(FHIRPathParser::BooleanLiteralContext * /*ctx*/) override { }
+
+  virtual void enterStringLiteral(FHIRPathParser::StringLiteralContext * /*ctx*/) override { }
+  virtual void exitStringLiteral(FHIRPathParser::StringLiteralContext * /*ctx*/) override { }
+
+  virtual void enterNumberLiteral(FHIRPathParser::NumberLiteralContext * /*ctx*/) override { }
+  virtual void exitNumberLiteral(FHIRPathParser::NumberLiteralContext * /*ctx*/) override { }
+
+  virtual void enterDateTimeLiteral(FHIRPathParser::DateTimeLiteralContext * /*ctx*/) override { }
+  virtual void exitDateTimeLiteral(FHIRPathParser::DateTimeLiteralContext * /*ctx*/) override { }
+
+  virtual void enterTimeLiteral(FHIRPathParser::TimeLiteralContext * /*ctx*/) override { }
+  virtual void exitTimeLiteral(FHIRPathParser::TimeLiteralContext * /*ctx*/) override { }
+
+  virtual void enterQuantityLiteral(FHIRPathParser::QuantityLiteralContext * /*ctx*/) override { }
+  virtual void exitQuantityLiteral(FHIRPathParser::QuantityLiteralContext * /*ctx*/) override { }
+
+  virtual void enterExternalConstant(FHIRPathParser::ExternalConstantContext * /*ctx*/) override { }
+  virtual void exitExternalConstant(FHIRPathParser::ExternalConstantContext * /*ctx*/) override { }
+
+  virtual void enterMemberInvocation(FHIRPathParser::MemberInvocationContext * /*ctx*/) override { }
+  virtual void exitMemberInvocation(FHIRPathParser::MemberInvocationContext * /*ctx*/) override { }
+
+  virtual void enterFunctionInvocation(FHIRPathParser::FunctionInvocationContext * /*ctx*/) override { }
+  virtual void exitFunctionInvocation(FHIRPathParser::FunctionInvocationContext * /*ctx*/) override { }
+
+  virtual void enterThisInvocation(FHIRPathParser::ThisInvocationContext * /*ctx*/) override { }
+  virtual void exitThisInvocation(FHIRPathParser::ThisInvocationContext * /*ctx*/) override { }
+
+  virtual void enterIndexInvocation(FHIRPathParser::IndexInvocationContext * /*ctx*/) override { }
+  virtual void exitIndexInvocation(FHIRPathParser::IndexInvocationContext * /*ctx*/) override { }
+
+  virtual void enterTotalInvocation(FHIRPathParser::TotalInvocationContext * /*ctx*/) override { }
+  virtual void exitTotalInvocation(FHIRPathParser::TotalInvocationContext * /*ctx*/) override { }
+
+  virtual void enterFunctn(FHIRPathParser::FunctnContext * /*ctx*/) override { }
+  virtual void exitFunctn(FHIRPathParser::FunctnContext * /*ctx*/) override { }
+
+  virtual void enterParamList(FHIRPathParser::ParamListContext * /*ctx*/) override { }
+  virtual void exitParamList(FHIRPathParser::ParamListContext * /*ctx*/) override { }
+
+  virtual void enterQuantity(FHIRPathParser::QuantityContext * /*ctx*/) override { }
+  virtual void exitQuantity(FHIRPathParser::QuantityContext * /*ctx*/) override { }
+
+  virtual void enterUnit(FHIRPathParser::UnitContext * /*ctx*/) override { }
+  virtual void exitUnit(FHIRPathParser::UnitContext * /*ctx*/) override { }
+
+  virtual void enterDateTimePrecision(FHIRPathParser::DateTimePrecisionContext * /*ctx*/) override { }
+  virtual void exitDateTimePrecision(FHIRPathParser::DateTimePrecisionContext * /*ctx*/) override { }
+
+  virtual void enterPluralDateTimePrecision(FHIRPathParser::PluralDateTimePrecisionContext * /*ctx*/) override { }
+  virtual void exitPluralDateTimePrecision(FHIRPathParser::PluralDateTimePrecisionContext * /*ctx*/) override { }
+
+  virtual void enterTypeSpecifier(FHIRPathParser::TypeSpecifierContext * /*ctx*/) override { }
+  virtual void exitTypeSpecifier(FHIRPathParser::TypeSpecifierContext * /*ctx*/) override { }
+
+  virtual void enterQualifiedIdentifier(FHIRPathParser::QualifiedIdentifierContext * /*ctx*/) override { }
+  virtual void exitQualifiedIdentifier(FHIRPathParser::QualifiedIdentifierContext * /*ctx*/) override { }
+
+  virtual void enterIdentifier(FHIRPathParser::IdentifierContext * /*ctx*/) override { }
+  virtual void exitIdentifier(FHIRPathParser::IdentifierContext * /*ctx*/) override { }
+
+
+  virtual void enterEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
+  virtual void exitEveryRule(antlr4::ParserRuleContext * /*ctx*/) override { }
+  virtual void visitTerminal(antlr4::tree::TerminalNode * /*node*/) override { }
+  virtual void visitErrorNode(antlr4::tree::ErrorNode * /*node*/) override { }
+
+};
+

data/ext/fhir_path_parser/antlrgen/FHIRPathBaseVisitor.cpp

@@ -0,0 +1,7 @@
+
+// Generated from /home/runner/work/fhirpath-ruby/fhirpath-ruby/lib/fhirpath/parser/FHIRPath.g4 by ANTLR 4.10.1
+
+
+#include "FHIRPathBaseVisitor.h"
+
+

data/ext/fhir_path_parser/antlrgen/FHIRPathBaseVisitor.h

@@ -0,0 +1,184 @@
+
+// Generated from /home/runner/work/fhirpath-ruby/fhirpath-ruby/lib/fhirpath/parser/FHIRPath.g4 by ANTLR 4.10.1
+
+#pragma once
+
+
+#include "antlr4-runtime.h"
+#include "FHIRPathVisitor.h"
+
+
+/**
+ * This class provides an empty implementation of FHIRPathVisitor, which can be
+ * extended to create a visitor which only needs to handle a subset of the available methods.
+ */
+class  FHIRPathBaseVisitor : public FHIRPathVisitor {
+public:
+
+  virtual std::any visitEntireExpression(FHIRPathParser::EntireExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitIndexerExpression(FHIRPathParser::IndexerExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitPolarityExpression(FHIRPathParser::PolarityExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitAdditiveExpression(FHIRPathParser::AdditiveExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitMultiplicativeExpression(FHIRPathParser::MultiplicativeExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitUnionExpression(FHIRPathParser::UnionExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitOrExpression(FHIRPathParser::OrExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitAndExpression(FHIRPathParser::AndExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitMembershipExpression(FHIRPathParser::MembershipExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitInequalityExpression(FHIRPathParser::InequalityExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitInvocationExpression(FHIRPathParser::InvocationExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitEqualityExpression(FHIRPathParser::EqualityExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitImpliesExpression(FHIRPathParser::ImpliesExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitTermExpression(FHIRPathParser::TermExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitTypeExpression(FHIRPathParser::TypeExpressionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitInvocationTerm(FHIRPathParser::InvocationTermContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitLiteralTerm(FHIRPathParser::LiteralTermContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitExternalConstantTerm(FHIRPathParser::ExternalConstantTermContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitParenthesizedTerm(FHIRPathParser::ParenthesizedTermContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitNullLiteral(FHIRPathParser::NullLiteralContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitBooleanLiteral(FHIRPathParser::BooleanLiteralContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitStringLiteral(FHIRPathParser::StringLiteralContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitNumberLiteral(FHIRPathParser::NumberLiteralContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitDateTimeLiteral(FHIRPathParser::DateTimeLiteralContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitTimeLiteral(FHIRPathParser::TimeLiteralContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitQuantityLiteral(FHIRPathParser::QuantityLiteralContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitExternalConstant(FHIRPathParser::ExternalConstantContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitMemberInvocation(FHIRPathParser::MemberInvocationContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitFunctionInvocation(FHIRPathParser::FunctionInvocationContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitThisInvocation(FHIRPathParser::ThisInvocationContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitIndexInvocation(FHIRPathParser::IndexInvocationContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitTotalInvocation(FHIRPathParser::TotalInvocationContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitFunctn(FHIRPathParser::FunctnContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitParamList(FHIRPathParser::ParamListContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitQuantity(FHIRPathParser::QuantityContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitUnit(FHIRPathParser::UnitContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitDateTimePrecision(FHIRPathParser::DateTimePrecisionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitPluralDateTimePrecision(FHIRPathParser::PluralDateTimePrecisionContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitTypeSpecifier(FHIRPathParser::TypeSpecifierContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitQualifiedIdentifier(FHIRPathParser::QualifiedIdentifierContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+  virtual std::any visitIdentifier(FHIRPathParser::IdentifierContext *ctx) override {
+    return visitChildren(ctx);
+  }
+
+
+};
+