Package org.hl7.fhir.dstu2.utils

Class FHIRPathEngine

java.lang.Object

org.hl7.fhir.dstu2.utils.FHIRPathEngine

public class FHIRPathEngine
extends Object

Author:

Grahame Grieve

Nested Class Summary

Nested Classes

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

Constructor Summary

Constructors

Constructor	Description
FHIRPathEngine(IWorkerContext worker)

Method Summary

Modifier and Type	Method	Description
ExpressionNode.TypeDetails	check(Object appContext, String resourceType, String context, String expr)
ExpressionNode.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
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
List<Base>	evaluate(Object appContext, Base resource, Base base, ExpressionNode ExpressionNode)	evaluate a path and return the matching elements
List<Base>	evaluate(Object appContext, Resource resource, Base base, String path)	evaluate a path and return the matching elements
List<Base>	evaluate(Object appContext, Resource resource, 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
boolean	evaluateToBoolean(Base resource, Base base, ExpressionNode node)	evaluate a path and return true or false (e.g.
boolean	evaluateToBoolean(Resource resource, Base base, String path)	evaluate a path and return true or false (e.g.
boolean	evaluateToBoolean(Resource resource, Base base, ExpressionNode node)	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	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	getConstantResolver()
boolean	hasLog()
ExpressionNode	parse(String path)	Parse a path for later use using execute
ExpressionNode	parse(FHIRLexer lexer)	Parse a path that is part of some other syntax
void	setConstantResolver(FHIRPathEngine.IEvaluationContext constantResolver)
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

getConstantResolver

public FHIRPathEngine.IEvaluationContext getConstantResolver()

setConstantResolver

public void setConstantResolver(FHIRPathEngine.IEvaluationContext constantResolver)

getChildrenByName

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

Parameters:

item -

name -

result -

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(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 ExpressionNode.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 ExpressionNode.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.PathEngineException

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.PathEngineException

evaluate

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

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:

FHIRLexer.FHIRLexerException

org.hl7.fhir.exceptions.PathEngineException

evaluate

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

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.PathEngineException

evaluate

public List<Base> evaluate(Object appContext,
                           Base resource,
                           Base base,
                           ExpressionNode ExpressionNode)
                    throws org.hl7.fhir.exceptions.PathEngineException

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.PathEngineException

evaluate

public List<Base> evaluate(Object appContext,
                           Resource resource,
                           Base base,
                           String path)
                    throws org.hl7.fhir.exceptions.PathEngineException,
                           FHIRLexer.FHIRLexerException

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.PathEngineException

FHIRLexer.FHIRLexerException

evaluateToBoolean

public boolean evaluateToBoolean(Resource resource,
                                 Base base,
                                 String path)
                          throws org.hl7.fhir.exceptions.PathEngineException,
                                 FHIRLexer.FHIRLexerException

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:

FHIRLexer.FHIRLexerException

org.hl7.fhir.exceptions.PathEngineException

evaluateToBoolean

public boolean evaluateToBoolean(Resource resource,
                                 Base base,
                                 ExpressionNode node)
                          throws org.hl7.fhir.exceptions.PathEngineException

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.PathEngineException

evaluateToBoolean

public boolean evaluateToBoolean(Base resource,
                                 Base base,
                                 ExpressionNode node)
                          throws org.hl7.fhir.exceptions.PathEngineException

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.PathEngineException

evaluateToString

public String evaluateToString(Base base,
                               String path)
                        throws FHIRLexer.FHIRLexerException,
                               org.hl7.fhir.exceptions.PathEngineException

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:

FHIRLexer.FHIRLexerException

org.hl7.fhir.exceptions.PathEngineException

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:

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()

hasLog

public boolean hasLog()

takeLog

public String takeLog()