Package org.hl7.fhir.r4.fhirpath

Class FHIRPathEngine

java.lang.Object

org.hl7.fhir.r4.fhirpath.FHIRPathEngine

public class FHIRPathEngine
extends Object

Author:

Grahame Grieve

Nested Class Summary

Nested Classes

Modifier and Type	Class	Description
static class	FHIRPathEngine.ExpressionNodeWithOffset
class	FHIRPathEngine.ExtensionDefinition
class	FHIRPathEngine.IssueMessage

Constructor Summary

Constructors

Constructor	Description
FHIRPathEngine(IWorkerContext worker)
FHIRPathEngine(IWorkerContext worker, ProfileUtilities utilities)

Method Summary

Modifier and Type	Method	Description
static String	bytesToHex(byte[] bytes)
TypeDetails	check(Object appContext, String rootResourceType, String resourceType, String context, String expr)
TypeDetails	check(Object appContext, String rootResourceType, 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 rootResourceType, String resourceType, String context, ExpressionNode expr, Set<ElementDefinition> elementDependencies)	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 rootResourceType, String resourceType, List<String> resourceTypes, ExpressionNode expr, Set<ElementDefinition> elementDependencies)	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 rootResourceType, StructureDefinition sd, String context, ExpressionNode expr)
TypeDetails	check(Object appContext, String rootResourceType, StructureDefinition sd, ExpressionNode expr)
TypeDetails	checkOnTypes(Object appContext, String rootResourceType, String resourceType, List<String> typeList, ExpressionNode expr, List<FHIRPathEngine.IssueMessage> warnings)	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	checkOnTypes(Object appContext, String rootResourceType, String resourceType, TypeDetails types, ExpressionNode expr, List<FHIRPathEngine.IssueMessage> warnings)
TypeDetails	checkOnTypes(Object appContext, String rootResourceType, String resourceType, TypeDetails types, ExpressionNode expr, List<FHIRPathEngine.IssueMessage> warnings, boolean canBeNone)
boolean	convertToBoolean(List<Base> items)	worker routine for converting a set of objects to a boolean representation (for invariants)
String	convertToString(List<Base> items)	worker routine for converting a set of objects to a string representation
String	convertToString(Base item)
List<Base>	evaluate(Object appContext, Base base, ExpressionNode ExpressionNode)	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, String path)	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(Base base, String path)	evaluate a path and return the matching elements
List<Base>	evaluate(Base base, ExpressionNode ExpressionNode)	evaluate a path and return the matching elements
FHIRPathUtilityClasses.TypedElementDefinition	evaluateDefinition(ExpressionNode expr, StructureDefinition profile, FHIRPathUtilityClasses.TypedElementDefinition element, StructureDefinition source, boolean dontWalkIntoReferences)	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. for an invariant)
boolean	evaluateToBoolean(Object appInfo, Resource focusResource, Resource rootResource, Base base, ExpressionNode node)	evaluate a path and return true or false (e.g. for an invariant)
boolean	evaluateToBoolean(Resource focusResource, Resource rootResource, Base base, String path)	evaluate a path and return true or false (e.g. for an invariant)
boolean	evaluateToBoolean(Resource focusResource, Resource rootResource, Base base, ExpressionNode node)	evaluate a path and return true or false (e.g. for an invariant)
String	evaluateToString(Object appInfo, Base focusResource, Base rootResource, Base base, ExpressionNode node)
String	evaluateToString(Base base, String path)	evaluate a path and a string containing the outcome (for display)
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. value[x]) - a name with a type replacement e.g. valueCodeableConcept - * which means all children - ** which means all descendants
List<org.hl7.fhir.r4.fhirpath.FHIRPathEngine.ElementDefinitionMatch>	getElementDefinition(StructureDefinition sd, String path, boolean allowTypedName, ExpressionNode expr)
IHostApplicationServices	getHostServices()
String	getLocation()
ProfileUtilities	getProfileUtilities()
org.hl7.fhir.utilities.validation.ValidationOptions	getTerminologyServiceOptions()
IWorkerContext	getWorker()
boolean	hasLog()
static byte[]	hexStringToByteArray(String s)
boolean	isAllowDoubleQuotes()
boolean	isAllowPolymorphicNames()
boolean	isDoImplicitStringConversion()
boolean	isDoNotEnforceAsCaseSensitive()
boolean	isDoNotEnforceAsSingletonRule()
boolean	isEmitSQLonFHIRWarning()
boolean	isLegacyMode()
boolean	isLiquidMode()
ExpressionNode	parse(String path)	Parse a path for later use using execute
ExpressionNode	parse(String path, String name)
ExpressionNode	parse(FHIRLexer lexer)	Parse a path that is part of some other syntax
FHIRPathEngine.ExpressionNodeWithOffset	parsePartial(String path, int i)	Parse a path for later use using execute
Quantity	parseQuantityString(String s)
void	setAllowDoubleQuotes(boolean allowDoubleQuotes)
void	setAllowPolymorphicNames(boolean allowPolymorphicNames)
void	setDoImplicitStringConversion(boolean doImplicitStringConversion)
void	setDoNotEnforceAsCaseSensitive(boolean doNotEnforceAsCaseSensitive)
void	setDoNotEnforceAsSingletonRule(boolean doNotEnforceAsSingletonRule)
void	setEmitSQLonFHIRWarning(boolean emitSQLonFHIRWarning)
void	setHostServices(IHostApplicationServices constantResolver)
void	setLegacyMode(boolean legacyMode)
void	setLiquidMode(boolean liquidMode)
void	setLocation(String location)
String	takeLog()

Methods inherited from class java.lang.Object

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

Constructor Details

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)

FHIRPathEngine

public FHIRPathEngine(IWorkerContext worker,
 ProfileUtilities utilities)

Method Details

getHostServices

public IHostApplicationServices getHostServices()

setHostServices

public void setHostServices(IHostApplicationServices constantResolver)

getLocation

public String getLocation()

setLocation

public void setLocation(String location)

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)

isDoImplicitStringConversion

public boolean isDoImplicitStringConversion()

setDoImplicitStringConversion

public void setDoImplicitStringConversion(boolean doImplicitStringConversion)

isDoNotEnforceAsSingletonRule

public boolean isDoNotEnforceAsSingletonRule()

setDoNotEnforceAsSingletonRule

public void setDoNotEnforceAsSingletonRule(boolean doNotEnforceAsSingletonRule)

isDoNotEnforceAsCaseSensitive

public boolean isDoNotEnforceAsCaseSensitive()

setDoNotEnforceAsCaseSensitive

public void setDoNotEnforceAsCaseSensitive(boolean doNotEnforceAsCaseSensitive)

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 rootResourceType,
 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,
 String rootResourceType,
 String resourceType,
 String context,
 ExpressionNode expr,
 Set<ElementDefinition> elementDependencies)
                  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

checkOnTypes

public TypeDetails checkOnTypes(Object appContext,
 String rootResourceType,
 String resourceType,
 List<String> typeList,
 ExpressionNode expr,
 List<FHIRPathEngine.IssueMessage> warnings)
                         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

checkOnTypes

public TypeDetails checkOnTypes(Object appContext,
 String rootResourceType,
 String resourceType,
 TypeDetails types,
 ExpressionNode expr,
 List<FHIRPathEngine.IssueMessage> warnings)
                         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

checkOnTypes

public TypeDetails checkOnTypes(Object appContext,
 String rootResourceType,
 String resourceType,
 TypeDetails types,
 ExpressionNode expr,
 List<FHIRPathEngine.IssueMessage> warnings,
 boolean canBeNone)
                         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 rootResourceType,
 String resourceType,
 List<String> resourceTypes,
 ExpressionNode expr,
 Set<ElementDefinition> elementDependencies)
                  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

Throws:

org.hl7.fhir.exceptions.DefinitionException

org.hl7.fhir.exceptions.PathEngineException

FHIRLexer.FHIRLexerException

check

public TypeDetails check(Object appContext,
 String rootResourceType,
 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,
 String rootResourceType,
 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 rootResourceType,
 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(Object appContext,
 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()

bytesToHex

public static String bytesToHex(byte[] bytes)

hexStringToByteArray

public static byte[] hexStringToByteArray(String s)

parseQuantityString

public Quantity parseQuantityString(String s)

getElementDefinition

public List<org.hl7.fhir.r4.fhirpath.FHIRPathEngine.ElementDefinitionMatch> getElementDefinition(StructureDefinition sd,
 String path,
 boolean allowTypedName,
 ExpressionNode expr)
                                                                                          throws org.hl7.fhir.exceptions.PathEngineException

Throws:

org.hl7.fhir.exceptions.PathEngineException

hasLog

public boolean hasLog()

takeLog

public String takeLog()

evaluateDefinition

public FHIRPathUtilityClasses.TypedElementDefinition evaluateDefinition(ExpressionNode expr,
 StructureDefinition profile,
 FHIRPathUtilityClasses.TypedElementDefinition element,
 StructureDefinition source,
 boolean dontWalkIntoReferences)
                                                                 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.validation.ValidationOptions getTerminologyServiceOptions()

getWorker

public IWorkerContext getWorker()

isAllowPolymorphicNames

public boolean isAllowPolymorphicNames()

setAllowPolymorphicNames

public void setAllowPolymorphicNames(boolean allowPolymorphicNames)

isLiquidMode

public boolean isLiquidMode()

setLiquidMode

public void setLiquidMode(boolean liquidMode)

getProfileUtilities

public ProfileUtilities getProfileUtilities()

isAllowDoubleQuotes

public boolean isAllowDoubleQuotes()

setAllowDoubleQuotes

public void setAllowDoubleQuotes(boolean allowDoubleQuotes)

isEmitSQLonFHIRWarning

public boolean isEmitSQLonFHIRWarning()

setEmitSQLonFHIRWarning

public void setEmitSQLonFHIRWarning(boolean emitSQLonFHIRWarning)