org.hl7.fhir.r4.utils

Class FHIRPathEngine

java.lang.Object

org.hl7.fhir.r4.utils.FHIRPathEngine

public class FHIRPathEngine
extends Object

Author:

Grahame Grieve

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
class	FHIRPathEngine.ElementDefinitionMatch
static class	FHIRPathEngine.ExpressionNodeWithOffset
static interface	FHIRPathEngine.IEvaluationContext

Constructor Summary

Constructors

Constructor and Description
FHIRPathEngine(IWorkerContext worker)

Method Summary

Modifier and Type	Method and Description
TypeDetails	check(Object appContext, String resourceType, String context, ExpressionNode expr) check that paths referred to in the ExpressionNode are valid xPathStartsWithValueRef is a hack work around for the fact that FHIR Path sometimes needs a different starting point than the xpath returns a list of the possible types that might be returned by executing the ExpressionNode against a particular context
TypeDetails	check(Object appContext, String resourceType, String context, String expr)
TypeDetails	check(Object appContext, StructureDefinition sd, ExpressionNode expr)
TypeDetails	check(Object appContext, StructureDefinition sd, String context, ExpressionNode expr)
boolean	convertToBoolean(List<Base> items) worker routine for converting a set of objects to a boolean representation (for invariants)
String	convertToString(Base item)
String	convertToString(List<Base> items) worker routine for converting a set of objects to a string representation
List<Base>	evaluate(Base base, ExpressionNode ExpressionNode) evaluate a path and return the matching elements
List<Base>	evaluate(Base base, String path) evaluate a path and return the matching elements
List<Base>	evaluate(Object appContext, Base focusResource, Base rootResource, Base base, ExpressionNode ExpressionNode) evaluate a path and return the matching elements
List<Base>	evaluate(Object appContext, Resource focusResource, Resource rootResource, Base base, ExpressionNode ExpressionNode) evaluate a path and return the matching elements
List<Base>	evaluate(Object appContext, Resource focusResource, Resource rootResource, Base base, String path) evaluate a path and return the matching elements
ElementDefinition	evaluateDefinition(ExpressionNode expr, StructureDefinition profile, ElementDefinition element) given an element definition in a profile, what element contains the differentiating fixed for the element, given the differentiating expresssion.
boolean	evaluateToBoolean(Object appInfo, Base focusResource, Base rootResource, Base base, ExpressionNode node) evaluate a path and return true or false (e.g.
boolean	evaluateToBoolean(Object appInfo, Resource focusResource, Resource rootResource, Base base, ExpressionNode node) evaluate a path and return true or false (e.g.
boolean	evaluateToBoolean(Resource focusResource, Resource rootResource, Base base, ExpressionNode node) evaluate a path and return true or false (e.g.
boolean	evaluateToBoolean(Resource focusResource, Resource rootResource, Base base, String path) evaluate a path and return true or false (e.g.
String	evaluateToString(Base base, String path) evaluate a path and a string containing the outcome (for display)
String	evaluateToString(Object appInfo, Base focusResource, Base rootResource, Base base, ExpressionNode node)
String	forLog()
protected void	getChildrenByName(Base item, String name, List<Base> result) Given an item, return all the children that conform to the pattern described in name Possible patterns: - a simple name (which may be the base of a name with [] e.g.
FHIRPathEngine.IEvaluationContext	getHostServices()
org.hl7.fhir.utilities.TerminologyServiceOptions	getTerminologyServiceOptions()
IWorkerContext	getWorker()
boolean	hasLog()
boolean	isLegacyMode()
ExpressionNode	parse(FHIRLexer lexer) Parse a path that is part of some other syntax
ExpressionNode	parse(String path) Parse a path for later use using execute
ExpressionNode	parse(String path, String name)
FHIRPathEngine.ExpressionNodeWithOffset	parsePartial(String path, int i) Parse a path for later use using execute
Quantity	parseQuantityString(String s)
void	setHostServices(FHIRPathEngine.IEvaluationContext constantResolver)
void	setLegacyMode(boolean legacyMode)
String	takeLog()

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

FHIRPathEngine

public FHIRPathEngine(IWorkerContext worker)

Parameters:

worker - - used when validating paths (@check), and used doing value set membership when executing tests (once that's defined)

Method Detail

getHostServices

public FHIRPathEngine.IEvaluationContext getHostServices()

setHostServices

public void setHostServices(FHIRPathEngine.IEvaluationContext constantResolver)

getChildrenByName

protected void getChildrenByName(Base item,
                                 String name,
                                 List<Base> result)
                          throws org.hl7.fhir.exceptions.FHIRException

Given an item, return all the children that conform to the pattern described in name Possible patterns: - a simple name (which may be the base of a name with [] e.g. value[x]) - a name with a type replacement e.g. valueCodeableConcept - * which means all children - ** which means all descendants

Parameters:

item -

name -

result -

Throws:

org.hl7.fhir.exceptions.FHIRException

isLegacyMode

public boolean isLegacyMode()

setLegacyMode

public void setLegacyMode(boolean legacyMode)

parse

public ExpressionNode parse(String path)
                     throws FHIRLexer.FHIRLexerException

Parse a path for later use using execute

Parameters:

path -

Returns:

Throws:

org.hl7.fhir.exceptions.PathEngineException

Exception

FHIRLexer.FHIRLexerException

parse

public ExpressionNode parse(String path,
                            String name)
                     throws FHIRLexer.FHIRLexerException

Throws:

FHIRLexer.FHIRLexerException

parsePartial

public FHIRPathEngine.ExpressionNodeWithOffset parsePartial(String path,
                                                            int i)
                                                     throws FHIRLexer.FHIRLexerException

Parse a path for later use using execute

Parameters:

path -

Returns:

Throws:

org.hl7.fhir.exceptions.PathEngineException

Exception

FHIRLexer.FHIRLexerException

parse

public ExpressionNode parse(FHIRLexer lexer)
                     throws FHIRLexer.FHIRLexerException

Parse a path that is part of some other syntax

Returns:

Throws:

org.hl7.fhir.exceptions.PathEngineException

Exception

FHIRLexer.FHIRLexerException

check

public TypeDetails check(Object appContext,
                         String resourceType,
                         String context,
                         ExpressionNode expr)
                  throws FHIRLexer.FHIRLexerException,
                         org.hl7.fhir.exceptions.PathEngineException,
                         org.hl7.fhir.exceptions.DefinitionException

check that paths referred to in the ExpressionNode are valid xPathStartsWithValueRef is a hack work around for the fact that FHIR Path sometimes needs a different starting point than the xpath returns a list of the possible types that might be returned by executing the ExpressionNode against a particular context

Parameters:

context - - the logical type against which this path is applied

Throws:

org.hl7.fhir.exceptions.DefinitionException

org.hl7.fhir.exceptions.PathEngineException

FHIRLexer.FHIRLexerException

check

public TypeDetails check(Object appContext,
                         StructureDefinition sd,
                         String context,
                         ExpressionNode expr)
                  throws FHIRLexer.FHIRLexerException,
                         org.hl7.fhir.exceptions.PathEngineException,
                         org.hl7.fhir.exceptions.DefinitionException

Throws:

FHIRLexer.FHIRLexerException

org.hl7.fhir.exceptions.PathEngineException

org.hl7.fhir.exceptions.DefinitionException

check

public TypeDetails check(Object appContext,
                         StructureDefinition sd,
                         ExpressionNode expr)
                  throws FHIRLexer.FHIRLexerException,
                         org.hl7.fhir.exceptions.PathEngineException,
                         org.hl7.fhir.exceptions.DefinitionException

Throws:

FHIRLexer.FHIRLexerException

org.hl7.fhir.exceptions.PathEngineException

org.hl7.fhir.exceptions.DefinitionException

check

public TypeDetails check(Object appContext,
                         String resourceType,
                         String context,
                         String expr)
                  throws FHIRLexer.FHIRLexerException,
                         org.hl7.fhir.exceptions.PathEngineException,
                         org.hl7.fhir.exceptions.DefinitionException

Throws:

FHIRLexer.FHIRLexerException

org.hl7.fhir.exceptions.PathEngineException

org.hl7.fhir.exceptions.DefinitionException

evaluate

public List<Base> evaluate(Base base,
                           ExpressionNode ExpressionNode)
                    throws org.hl7.fhir.exceptions.FHIRException

evaluate a path and return the matching elements

Parameters:

base - - the object against which the path is being evaluated

ExpressionNode - - the parsed ExpressionNode statement to use

Returns:

Throws:

org.hl7.fhir.exceptions.FHIRException

evaluate

public List<Base> evaluate(Base base,
                           String path)
                    throws org.hl7.fhir.exceptions.FHIRException

evaluate a path and return the matching elements

Parameters:

base - - the object against which the path is being evaluated

path - - the FHIR Path statement to use

Returns:

Throws:

org.hl7.fhir.exceptions.FHIRException

evaluate

public List<Base> evaluate(Object appContext,
                           Resource focusResource,
                           Resource rootResource,
                           Base base,
                           ExpressionNode ExpressionNode)
                    throws org.hl7.fhir.exceptions.FHIRException

evaluate a path and return the matching elements

Parameters:

base - - the object against which the path is being evaluated

ExpressionNode - - the parsed ExpressionNode statement to use

Returns:

Throws:

org.hl7.fhir.exceptions.FHIRException

evaluate

public List<Base> evaluate(Object appContext,
                           Base focusResource,
                           Base rootResource,
                           Base base,
                           ExpressionNode ExpressionNode)
                    throws org.hl7.fhir.exceptions.FHIRException

evaluate a path and return the matching elements

Parameters:

base - - the object against which the path is being evaluated

ExpressionNode - - the parsed ExpressionNode statement to use

Returns:

Throws:

org.hl7.fhir.exceptions.FHIRException

evaluate

public List<Base> evaluate(Object appContext,
                           Resource focusResource,
                           Resource rootResource,
                           Base base,
                           String path)
                    throws org.hl7.fhir.exceptions.FHIRException

evaluate a path and return the matching elements

Parameters:

base - - the object against which the path is being evaluated

path - - the FHIR Path statement to use

Returns:

Throws:

org.hl7.fhir.exceptions.FHIRException

evaluateToBoolean

public boolean evaluateToBoolean(Resource focusResource,
                                 Resource rootResource,
                                 Base base,
                                 String path)
                          throws org.hl7.fhir.exceptions.FHIRException

evaluate a path and return true or false (e.g. for an invariant)

Parameters:

base - - the object against which the path is being evaluated

path - - the FHIR Path statement to use

Returns:

Throws:

org.hl7.fhir.exceptions.FHIRException

evaluateToBoolean

public boolean evaluateToBoolean(Resource focusResource,
                                 Resource rootResource,
                                 Base base,
                                 ExpressionNode node)
                          throws org.hl7.fhir.exceptions.FHIRException

evaluate a path and return true or false (e.g. for an invariant)

Parameters:

base - - the object against which the path is being evaluated

Returns:

Throws:

org.hl7.fhir.exceptions.FHIRException

evaluateToBoolean

public boolean evaluateToBoolean(Object appInfo,
                                 Resource focusResource,
                                 Resource rootResource,
                                 Base base,
                                 ExpressionNode node)
                          throws org.hl7.fhir.exceptions.FHIRException

evaluate a path and return true or false (e.g. for an invariant)

Parameters:

appInfo - - application context

base - - the object against which the path is being evaluated

Returns:

Throws:

org.hl7.fhir.exceptions.FHIRException

evaluateToBoolean

public boolean evaluateToBoolean(Object appInfo,
                                 Base focusResource,
                                 Base rootResource,
                                 Base base,
                                 ExpressionNode node)
                          throws org.hl7.fhir.exceptions.FHIRException

evaluate a path and return true or false (e.g. for an invariant)

Parameters:

base - - the object against which the path is being evaluated

Returns:

Throws:

org.hl7.fhir.exceptions.FHIRException

evaluateToString

public String evaluateToString(Base base,
                               String path)
                        throws org.hl7.fhir.exceptions.FHIRException

evaluate a path and a string containing the outcome (for display)

Parameters:

base - - the object against which the path is being evaluated

path - - the FHIR Path statement to use

Returns:

Throws:

org.hl7.fhir.exceptions.FHIRException

evaluateToString

public String evaluateToString(Object appInfo,
                               Base focusResource,
                               Base rootResource,
                               Base base,
                               ExpressionNode node)
                        throws org.hl7.fhir.exceptions.FHIRException

Throws:

org.hl7.fhir.exceptions.FHIRException

convertToString

public String convertToString(List<Base> items)

worker routine for converting a set of objects to a string representation

Parameters:

items - - result from @evaluate

Returns:

convertToString

public String convertToString(Base item)

convertToBoolean

public boolean convertToBoolean(List<Base> items)

worker routine for converting a set of objects to a boolean representation (for invariants)

Parameters:

items - - result from @evaluate

Returns:

forLog

public String forLog()

parseQuantityString

public Quantity parseQuantityString(String s)

hasLog

public boolean hasLog()

takeLog

public String takeLog()

evaluateDefinition

public ElementDefinition evaluateDefinition(ExpressionNode expr,
                                            StructureDefinition profile,
                                            ElementDefinition element)
                                     throws org.hl7.fhir.exceptions.DefinitionException

given an element definition in a profile, what element contains the differentiating fixed for the element, given the differentiating expresssion. The expression is only allowed to use a subset of FHIRPath

Parameters:

profile -

element -

Returns:

Throws:

org.hl7.fhir.exceptions.PathEngineException

org.hl7.fhir.exceptions.DefinitionException

getTerminologyServiceOptions

public org.hl7.fhir.utilities.TerminologyServiceOptions getTerminologyServiceOptions()

getWorker

public IWorkerContext getWorker()