All Downloads are FREE. Search and download functionalities are using the official Maven repository.
  • Log In
  • Register

    • ca.uhn.fhir.util.FhirTerser Maven / Gradle / Ivy

    There is a newer version: 7.6.1
    Show newest version
    package ca.uhn.fhir.util;

import static org.apache.commons.lang3.StringUtils.defaultString;

/*
 * #%L
 * HAPI FHIR - Core Library
 * %%
 * Copyright (C) 2014 - 2016 University Health Network
 * %%
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 * 
 *      http://www.apache.org/licenses/LICENSE-2.0
 * 
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 * #L%
 */
import java.util.*;

import org.apache.commons.lang3.Validate;
import org.hl7.fhir.instance.model.api.*;

import ca.uhn.fhir.context.*;
import ca.uhn.fhir.context.BaseRuntimeElementDefinition.ChildTypeEnum;
import ca.uhn.fhir.model.api.ExtensionDt;
import ca.uhn.fhir.model.api.IResource;
import ca.uhn.fhir.model.api.ISupportsUndeclaredExtensions;
import ca.uhn.fhir.model.base.composite.BaseContainedDt;
import ca.uhn.fhir.model.base.composite.BaseResourceReferenceDt;
import ca.uhn.fhir.model.primitive.StringDt;
import ca.uhn.fhir.parser.DataFormatException;

public class FhirTerser {

	private FhirContext myContext;

	public FhirTerser(FhirContext theContext) {
		super();
		myContext = theContext;
	}

	private List addNameToList(List theCurrentList, BaseRuntimeChildDefinition theChildDefinition) {
		if (theChildDefinition == null)
			return null;
		if (theCurrentList == null || theCurrentList.isEmpty())
			return new ArrayList(Arrays.asList(theChildDefinition.getElementName()));
		List newList = new ArrayList(theCurrentList);
		newList.add(theChildDefinition.getElementName());
		return newList;
	}
	

	/**
	 * Clones all values from a source object into the equivalent fields in a target object
	 * @param theSource The source object (must not be null)
	 * @param theTarget The target object to copy values into (must not be null)
	 * @param theIgnoreMissingFields The ignore fields in the target which do not exist (if false, an exception will be thrown if the target is unable to accept a value from the source)
	 */
	public void cloneInto(IBase theSource, IBase theTarget, boolean theIgnoreMissingFields) {
		Validate.notNull(theSource, "theSource must not be null");
		Validate.notNull(theTarget, "theTarget must not be null");
		
		if (theSource instanceof IPrimitiveType) {
			if (theTarget instanceof IPrimitiveType) {
				((IPrimitiveType)theTarget).setValueAsString(((IPrimitiveType)theSource).getValueAsString());
				return;
			} else {
				if (theIgnoreMissingFields) {
					return;
				} else {
					throw new DataFormatException("Can not copy value from primitive of type " + theSource.getClass().getName() + " into type " + theTarget.getClass().getName());
				}
			}
		}
		
		BaseRuntimeElementCompositeDefinition sourceDef = (BaseRuntimeElementCompositeDefinition) myContext.getElementDefinition(theSource.getClass()); 
		BaseRuntimeElementCompositeDefinition targetDef = (BaseRuntimeElementCompositeDefinition) myContext.getElementDefinition(theTarget.getClass());
		
		List children = sourceDef.getChildren();
		if (sourceDef instanceof RuntimeExtensionDtDefinition) {
			children = ((RuntimeExtensionDtDefinition)sourceDef).getChildrenIncludingUrl();
		}
		
		for (BaseRuntimeChildDefinition nextChild : children) {
			for (IBase nextValue : nextChild.getAccessor().getValues(theSource)) {
				String elementName = nextChild.getChildNameByDatatype(nextValue.getClass());
				BaseRuntimeChildDefinition targetChild = targetDef.getChildByName(elementName);
				if (targetChild == null) {
					if (theIgnoreMissingFields) {
						continue;
					} else {
						throw new DataFormatException("Type " + theTarget.getClass().getName() + " does not have a child with name " + elementName);
					}
				}
				
				BaseRuntimeElementDefinition childDef = targetChild.getChildByName(elementName);
				IBase target = childDef.newInstance();
				targetChild.getMutator().addValue(theTarget, target);
				cloneInto(nextValue, target, theIgnoreMissingFields);
			}
		}
		
	}

	/**
	 * Returns a list containing all child elements (including the resource itself) which are non-empty and are either of the exact type specified, or are a subclass of that type.
	 * 
    
	 * For example, specifying a type of {@link StringDt} would return all non-empty string instances within the message. Specifying a type of {@link IResource} would return the resource itself, as
	 * well as any contained resources.
	 * 
    
	 * 
    
	 * Note on scope: This method will descend into any contained resources ({@link IResource#getContained()}) as well, but will not descend into linked resources (e.g.
	 * {@link BaseResourceReferenceDt#getResource()}) or embedded resources (e.g. Bundle.entry.resource)
	 * 
    
	 * 
	 * @param theResource
	 *           The resource instance to search. Must not be null.
	 * @param theType
	 *           The type to search for. Must not be null.
	 * @return Returns a list of all matching elements
	 */
	public  List getAllPopulatedChildElementsOfType(IBaseResource theResource, final Class theType) {
		final ArrayList retVal = new ArrayList();
		BaseRuntimeElementCompositeDefinition def = myContext.getResourceDefinition(theResource);
		visit(new IdentityHashMap(), theResource, theResource, null, null, def, new IModelVisitor() {
			@SuppressWarnings("unchecked")
			@Override
			public void acceptElement(IBaseResource theOuterResource, IBase theElement, List thePathToElement, BaseRuntimeChildDefinition theChildDefinition, BaseRuntimeElementDefinition theDefinition) {
				if (theElement == null || theElement.isEmpty()) {
					return;
				}

				if (theType.isAssignableFrom(theElement.getClass())) {
					retVal.add((T) theElement);
				}
			}
		});
		return retVal;
	}

	public List getAllResourceReferences(final IBaseResource theResource) {
		final ArrayList retVal = new ArrayList();
		BaseRuntimeElementCompositeDefinition def = myContext.getResourceDefinition(theResource);
		visit(new IdentityHashMap(), theResource, theResource, null, null, def, new IModelVisitor() {
			@Override
			public void acceptElement(IBaseResource theOuterResource, IBase theElement, List thePathToElement, BaseRuntimeChildDefinition theChildDefinition, BaseRuntimeElementDefinition theDefinition) {
				if (theElement == null || theElement.isEmpty()) {
					return;
				}
				if (IBaseReference.class.isAssignableFrom(theElement.getClass())) {
					retVal.add(new ResourceReferenceInfo(myContext, theOuterResource, thePathToElement, (IBaseReference) theElement));
				}
			}
		});
		return retVal;
	}

	private BaseRuntimeChildDefinition getDefinition(BaseRuntimeElementCompositeDefinition theCurrentDef, List theSubList) {
		BaseRuntimeChildDefinition nextDef = theCurrentDef.getChildByNameOrThrowDataFormatException(theSubList.get(0));

		if (theSubList.size() == 1) {
			return nextDef;
		} else {
			BaseRuntimeElementCompositeDefinition cmp = (BaseRuntimeElementCompositeDefinition) nextDef.getChildByName(theSubList.get(0));
			return getDefinition(cmp, theSubList.subList(1, theSubList.size()));
		}
	}

	public BaseRuntimeChildDefinition getDefinition(Class theResourceType, String thePath) {
		RuntimeResourceDefinition def = myContext.getResourceDefinition(theResourceType);

		BaseRuntimeElementCompositeDefinition currentDef = def;

		List parts = Arrays.asList(thePath.split("\\."));
		List subList = parts.subList(1, parts.size());
		if (subList.size() < 1) {
			throw new ConfigurationException("Invalid path: " + thePath);
		}
		return getDefinition(currentDef, subList);

	}

	public Object getSingleValueOrNull(IBase theTarget, String thePath) {
		Class wantedType = Object.class;

		return getSingleValueOrNull(theTarget, thePath, wantedType);
	}

	public  T getSingleValueOrNull(IBase theTarget, String thePath, Class theWantedType) {
		Validate.notNull(theTarget, "theTarget must not be null");
		Validate.notBlank(thePath, "thePath must not be empty");

		BaseRuntimeElementDefinition def = myContext.getElementDefinition(theTarget.getClass());
		if (!(def instanceof BaseRuntimeElementCompositeDefinition)) {
			throw new IllegalArgumentException("Target is not a composite type: " + theTarget.getClass().getName());
		}

		BaseRuntimeElementCompositeDefinition currentDef = (BaseRuntimeElementCompositeDefinition) def;
		Object currentObj = theTarget;

		List parts = Arrays.asList(thePath.split("\\."));
		List retVal = getValues(currentDef, currentObj, parts, theWantedType);
		if (retVal.isEmpty()) {
			return null;
		} else {
			return retVal.get(0);
		}
	}

	@SuppressWarnings("unchecked")
	private  List getValues(BaseRuntimeElementCompositeDefinition theCurrentDef, Object theCurrentObj, List theSubList, Class theWantedClass) {
		String name = theSubList.get(0);
				
		BaseRuntimeChildDefinition nextDef = theCurrentDef.getChildByNameOrThrowDataFormatException(name);
		List values = nextDef.getAccessor().getValues(theCurrentObj);
		List retVal = new ArrayList();

		if (theSubList.size() == 1) {
			if (nextDef instanceof RuntimeChildChoiceDefinition) {
				for (IBase next : values) {
					if (next != null) {
						if (name.endsWith("[x]")) {
							if (theWantedClass == null || theWantedClass.isAssignableFrom(next.getClass())) {
								retVal.add((T) next);
							}
						} else {
							String childName = nextDef.getChildNameByDatatype(next.getClass());
							if (theSubList.get(0).equals(childName)) {
								if (theWantedClass == null || theWantedClass.isAssignableFrom(next.getClass())) {
									retVal.add((T) next);
								}
							}
						}
					}
				}
			} else {
				for (IBase next : values) {
					if (next != null) {
						if (theWantedClass == null || theWantedClass.isAssignableFrom(next.getClass())) {
							retVal.add((T) next);
						}
					}
				}
			}
		} else {
			for (IBase nextElement : values) {
				BaseRuntimeElementCompositeDefinition nextChildDef = (BaseRuntimeElementCompositeDefinition) myContext.getElementDefinition(nextElement.getClass());
				List foundValues = getValues(nextChildDef, nextElement, theSubList.subList(1, theSubList.size()), theWantedClass);
				retVal.addAll(foundValues);
			}
		}
		return retVal;
	}

	public List getValues(IBaseResource theResource, String thePath) {
		Class wantedClass = Object.class;

		return getValues(theResource, thePath, wantedClass);

	}

	public  List getValues(IBaseResource theResource, String thePath, Class theWantedClass) {
		RuntimeResourceDefinition def = myContext.getResourceDefinition(theResource);

		BaseRuntimeElementCompositeDefinition currentDef = def;
		Object currentObj = theResource;

		List parts = Arrays.asList(thePath.split("\\."));
		List subList = parts.subList(1, parts.size());
		if (subList.size() < 1) {
			throw new ConfigurationException("Invalid path: " + thePath);
		}
		return getValues(currentDef, currentObj, subList, theWantedClass);
	}

	/**
	 * Returns true if theSource is in the compartment named theCompartmentName
	 * belonging to resource theTarget
	 * 
	 * @param theCompartmentName The name of the compartment
	 * @param theSource The potential member of the compartment
	 * @param theTarget The owner of the compartment. Note that both the resource type and ID must be filled in on this IIdType or the method will throw an {@link IllegalArgumentException}
	 * @return true if theSource is in the compartment
	 * @throws IllegalArgumentException If theTarget does not contain both a resource type and ID
	 */
	public boolean isSourceInCompartmentForTarget(String theCompartmentName, IBaseResource theSource, IIdType theTarget) {
		Validate.notBlank(theCompartmentName, "theCompartmentName must not be null or blank");
		Validate.notNull(theSource, "theSource must not be null");
		Validate.notNull(theTarget, "theTarget must not be null");
		Validate.notBlank(defaultString(theTarget.getResourceType()), "theTarget must have a populated resource type (theTarget.getResourceType() does not return a value)");
		Validate.notBlank(defaultString(theTarget.getIdPart()), "theTarget must have a populated ID (theTarget.getIdPart() does not return a value)");
		
		String wantRef = theTarget.toUnqualifiedVersionless().getValue();
		
		RuntimeResourceDefinition sourceDef = myContext.getResourceDefinition(theSource);
		if (theSource.getIdElement().hasIdPart()) {
			if (wantRef.equals(sourceDef.getName() + '/' + theSource.getIdElement().getIdPart())) {
				return true;
			}
		}
		
		List params = sourceDef.getSearchParamsForCompartmentName(theCompartmentName);
		for (RuntimeSearchParam nextParam : params) {
			for (String nextPath : nextParam.getPathsSplit()) {
				for (IBaseReference nextValue : getValues(theSource, nextPath, IBaseReference.class)) {
					String nextRef = nextValue.getReferenceElement().toUnqualifiedVersionless().getValue();
					if (wantRef.equals(nextRef)) {
						return true;
					}
				}
			}
		}
		
		return false;
	}

	private void visit(IBase theElement, BaseRuntimeChildDefinition theChildDefinition, BaseRuntimeElementDefinition theDefinition, IModelVisitor2 theCallback, List theContainingElementPath,
			List theChildDefinitionPath, List> theElementDefinitionPath) {
		if (theChildDefinition != null) {
			theChildDefinitionPath.add(theChildDefinition);
		}
		theContainingElementPath.add(theElement);
		theElementDefinitionPath.add(theDefinition);

		theCallback.acceptElement(theElement, Collections.unmodifiableList(theContainingElementPath), Collections.unmodifiableList(theChildDefinitionPath),
				Collections.unmodifiableList(theElementDefinitionPath));

		/*
		 * Visit undeclared extensions
		 */
		if (theElement instanceof ISupportsUndeclaredExtensions) {
			ISupportsUndeclaredExtensions containingElement = (ISupportsUndeclaredExtensions) theElement;
			for (ExtensionDt nextExt : containingElement.getUndeclaredExtensions()) {
				theContainingElementPath.add(nextExt);
				theCallback.acceptUndeclaredExtension(nextExt, theContainingElementPath, theChildDefinitionPath, theElementDefinitionPath);
				theContainingElementPath.remove(theContainingElementPath.size() - 1);
			}
		}

		/*
		 * Now visit the children of the given element
		 */
		switch (theDefinition.getChildType()) {
		case ID_DATATYPE:
		case PRIMITIVE_XHTML_HL7ORG:
		case PRIMITIVE_XHTML:
		case PRIMITIVE_DATATYPE:
			// These are primitive types, so we don't need to visit their children
			break;
		case RESOURCE:
		case RESOURCE_BLOCK:
		case COMPOSITE_DATATYPE: {
			BaseRuntimeElementCompositeDefinition childDef = (BaseRuntimeElementCompositeDefinition) theDefinition;
			for (BaseRuntimeChildDefinition nextChild : childDef.getChildrenAndExtension()) {
				List values = nextChild.getAccessor().getValues(theElement);
				if (values != null) {
					for (IBase nextValue : values) {
						if (nextValue == null) {
							continue;
						}
						if (nextValue.isEmpty()) {
							continue;
						}
						BaseRuntimeElementDefinition childElementDef;
						childElementDef = nextChild.getChildElementDefinitionByDatatype(nextValue.getClass());

						if (childElementDef == null) {
							StringBuilder b = new StringBuilder();
							b.append("Found value of type[");
							b.append(nextValue.getClass().getSimpleName());
							b.append("] which is not valid for field[");
							b.append(nextChild.getElementName());
							b.append("] in ");
							b.append(childDef.getName());
							b.append(" - Valid types: ");
							for (Iterator iter = new TreeSet(nextChild.getValidChildNames()).iterator(); iter.hasNext();) {
								BaseRuntimeElementDefinition childByName = nextChild.getChildByName(iter.next());
								b.append(childByName.getImplementingClass().getSimpleName());
								if (iter.hasNext()) {
									b.append(", ");
								}
							}
							throw new DataFormatException(b.toString());
						}

						if (nextChild instanceof RuntimeChildDirectResource) {
							// Don't descend into embedded resources
							theContainingElementPath.add(nextValue);
							theChildDefinitionPath.add(nextChild);
							theElementDefinitionPath.add(myContext.getElementDefinition(nextValue.getClass()));
							theCallback.acceptElement(nextValue, Collections.unmodifiableList(theContainingElementPath), Collections.unmodifiableList(theChildDefinitionPath),
									Collections.unmodifiableList(theElementDefinitionPath));
							theChildDefinitionPath.remove(theChildDefinitionPath.size() - 1);
							theContainingElementPath.remove(theContainingElementPath.size() - 1);
							theElementDefinitionPath.remove(theElementDefinitionPath.size() - 1);
						} else {
							visit(nextValue, nextChild, childElementDef, theCallback, theContainingElementPath, theChildDefinitionPath, theElementDefinitionPath);
						}
					}
				}
			}
			break;
		}
		case CONTAINED_RESOURCES: {
			BaseContainedDt value = (BaseContainedDt) theElement;
			for (IResource next : value.getContainedResources()) {
				BaseRuntimeElementCompositeDefinition def = myContext.getResourceDefinition(next);
				visit(next, null, def, theCallback, theContainingElementPath, theChildDefinitionPath, theElementDefinitionPath);
			}
			break;
		}
		case EXTENSION_DECLARED:
		case UNDECL_EXT: {
			throw new IllegalStateException("state should not happen: " + theDefinition.getChildType());
		}
		case CONTAINED_RESOURCE_LIST: {
			if (theElement != null) {
				BaseRuntimeElementDefinition def = myContext.getElementDefinition(theElement.getClass());
				visit(theElement, null, def, theCallback, theContainingElementPath, theChildDefinitionPath, theElementDefinitionPath);
			}
			break;
		}
		}

		if (theChildDefinition != null) {
			theChildDefinitionPath.remove(theChildDefinitionPath.size() - 1);
		}
		theContainingElementPath.remove(theContainingElementPath.size() - 1);
		theElementDefinitionPath.remove(theElementDefinitionPath.size() - 1);
	}

	/**
	 * Visit all elements in a given resource
	 * 
	 * 
    
	 * Note on scope: This method will descend into any contained resources ({@link IResource#getContained()}) as well, but will not descend into linked resources (e.g.
	 * {@link BaseResourceReferenceDt#getResource()}) or embedded resources (e.g. Bundle.entry.resource)
	 * 
    
	 * 
	 * @param theResource
	 *           The resource to visit
	 * @param theVisitor
	 *           The visitor
	 */
	public void visit(IBaseResource theResource, IModelVisitor theVisitor) {
		BaseRuntimeElementCompositeDefinition def = myContext.getResourceDefinition(theResource);
		visit(new IdentityHashMap(), theResource, theResource, null, null, def, theVisitor);
	}

	/**
	 * Visit all elements in a given resource
	 * 
	 * THIS ALTERNATE METHOD IS STILL EXPERIMENTAL
	 * 
	 * 
    
	 * Note on scope: This method will descend into any contained resources ({@link IResource#getContained()}) as well, but will not descend into linked resources (e.g.
	 * {@link BaseResourceReferenceDt#getResource()}) or embedded resources (e.g. Bundle.entry.resource)
	 * 
    
	 * 
	 * @param theResource
	 *           The resource to visit
	 * @param theVisitor
	 *           The visitor
	 */
	void visit(IBaseResource theResource, IModelVisitor2 theVisitor) {
		BaseRuntimeElementCompositeDefinition def = myContext.getResourceDefinition(theResource);
		visit(theResource, null, def, theVisitor, new ArrayList(), new ArrayList(), new ArrayList>());
	}

	private void visit(IdentityHashMap theStack, IBaseResource theResource, IBase theElement, List thePathToElement, BaseRuntimeChildDefinition theChildDefinition,
			BaseRuntimeElementDefinition theDefinition, IModelVisitor theCallback) {
		List pathToElement = addNameToList(thePathToElement, theChildDefinition);

		if (theStack.put(theElement, theElement) != null) {
			return;
		}
		
		theCallback.acceptElement(theResource, theElement, pathToElement, theChildDefinition, theDefinition);

		BaseRuntimeElementDefinition def = theDefinition;
		if (def.getChildType() == ChildTypeEnum.CONTAINED_RESOURCE_LIST) {
			def = myContext.getElementDefinition(theElement.getClass());
		}
		
		if (theElement instanceof IBaseReference) {
			IBaseResource target = ((IBaseReference)theElement).getResource();
			if (target != null) {
				if (target.getIdElement().hasIdPart() == false || target.getIdElement().isLocal()) {
					RuntimeResourceDefinition targetDef = myContext.getResourceDefinition(target);
					visit(theStack, target, target, pathToElement, null, targetDef, theCallback);
				}
			}
		}
		
		switch (def.getChildType()) {
		case ID_DATATYPE:
		case PRIMITIVE_XHTML_HL7ORG:
		case PRIMITIVE_XHTML:
		case PRIMITIVE_DATATYPE:
			// These are primitive types
			break;
		case RESOURCE:
		case RESOURCE_BLOCK:
		case COMPOSITE_DATATYPE: {
			BaseRuntimeElementCompositeDefinition childDef = (BaseRuntimeElementCompositeDefinition) def;
			for (BaseRuntimeChildDefinition nextChild : childDef.getChildrenAndExtension()) {
				
				List values = nextChild.getAccessor().getValues(theElement);
				if (values != null) {
					for (Object nextValueObject : values) {
						IBase nextValue;
						try {
							nextValue = (IBase) nextValueObject;
						} catch (ClassCastException e) {
							String s = "Found instance of " + nextValueObject.getClass() + " - Did you set a field value to the incorrect type? Expected " + IBase.class.getName();
							throw new ClassCastException(s);
						}
						if (nextValue == null) {
							continue;
						}
						if (nextValue.isEmpty()) {
							continue;
						}
						BaseRuntimeElementDefinition childElementDef;
						childElementDef = nextChild.getChildElementDefinitionByDatatype(nextValue.getClass());

						if (childElementDef == null) {
							childElementDef = myContext.getElementDefinition(nextValue.getClass());
						}

						if (nextChild instanceof RuntimeChildDirectResource) {
							// Don't descend into embedded resources
							theCallback.acceptElement(theResource, nextValue, null, nextChild, childElementDef);
						} else {
							visit(theStack, theResource, nextValue, pathToElement, nextChild, childElementDef, theCallback);
						}
					}
				}
			}
			break;
		}
		case CONTAINED_RESOURCES: {
			BaseContainedDt value = (BaseContainedDt) theElement;
			for (IResource next : value.getContainedResources()) {
				def = myContext.getResourceDefinition(next);
				visit(theStack, next, next, pathToElement, null, def, theCallback);
			}
			break;
		}
		case CONTAINED_RESOURCE_LIST:
		case EXTENSION_DECLARED:
		case UNDECL_EXT: {
			throw new IllegalStateException("state should not happen: " + def.getChildType());
		}
		}
		
		theStack.remove(theElement);
		
	}

}
    
    
    
    

    




    
    
    © 2015 - 2025 Weber Informatics LLC | Privacy Policy