PropertyModifyingHelper.java

package ca.uhn.fhir.util;

/*-
 * #%L
 * HAPI FHIR - Core Library
 * %%
 * Copyright (C) 2014 - 2022 Smile CDR, Inc.
 * %%
 * 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 ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.i18n.Msg;
import org.apache.commons.lang3.StringUtils;
import org.hl7.fhir.instance.model.api.IBase;

import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Helper class for handling updates of the instances that support property modification via <code>setProperty</code>
 * and <code>getProperty</code> methods.
 */
public class PropertyModifyingHelper {

	public static final String GET_PROPERTY_METHOD_NAME = "getProperty";
	public static final String SET_PROPERTY_METHOD_NAME = "setProperty";
	public static final String DEFAULT_DELIMITER = ", ";

	private IBase myBase;

	private String myDelimiter = DEFAULT_DELIMITER;

	private FhirContext myFhirContext;

	/**
	 * Creates a new instance initializing the dependencies.
	 *
	 * @param theFhirContext FHIR context holding the resource definitions
	 * @param theBase        The base class to set properties on
	 */
	public PropertyModifyingHelper(FhirContext theFhirContext, IBase theBase) {
		if (findGetPropertyMethod(theBase) == null) {
			throw new IllegalArgumentException(Msg.code(1771) + "Specified base instance does not support property retrieval.");
		}
		myBase = theBase;
		myFhirContext = theFhirContext;
	}

	/**
	 * Gets the method with the specified name and parameter types.
	 *
	 * @param theObject       Non-null instance to get the method from
	 * @param theMethodName   Name of the method to get
	 * @param theParamClasses Parameters types that method parameters should be assignable as
	 * @return Returns the method with the given name and parameters or null if it can't be found
	 */
	protected Method getMethod(Object theObject, String theMethodName, Class... theParamClasses) {
		for (Method m : theObject.getClass().getDeclaredMethods()) {
			if (m.getName().equals(theMethodName)) {
				if (theParamClasses.length == 0) {
					return m;
				}
				if (m.getParameterCount() != theParamClasses.length) {
					continue;
				}
				for (int i = 0; i < theParamClasses.length; i++) {
					if (!m.getParameterTypes()[i].isAssignableFrom(theParamClasses[i])) {
						continue;
					}
				}
				return m;
			}
		}
		return null;
	}

	/**
	 * Gets all non-blank fields as a single string joined with the delimiter provided by {@link #getDelimiter()}
	 *
	 * @param theFiledNames Field names to retrieve values for
	 * @return Returns all specified non-blank fileds as a single string.
	 */
	public String getFields(String... theFiledNames) {
		return Arrays.stream(theFiledNames)
			.map(this::get)
			.filter(s -> !StringUtils.isBlank(s))
			.collect(Collectors.joining(getDelimiter()));
	}

	/**
	 * Gets property with the specified name from the provided base class.
	 *
	 * @param thePropertyName Name of the property to get
	 * @return Returns property value converted to string. In case of multiple values, they are joined with the
	 * specified delimiter.
	 */
	public String get(String thePropertyName) {
		return getMultiple(thePropertyName)
			.stream()
			.collect(Collectors.joining(getDelimiter()));
	}

	/**
	 * Sets property or adds to a collection of properties with the specified name from the provided base class.
	 *
	 * @param thePropertyName Name of the property to set or add element to in case property is a collection
	 */
	public void set(String thePropertyName, String theValue) {
		if (theValue == null || theValue.isEmpty()) {
			return;
		}

		try {
			IBase value = myFhirContext.getElementDefinition("string").newInstance(theValue);
			Method setPropertyMethod = findSetPropertyMethod(myBase, int.class, String.class, value.getClass());
			int hashCode = thePropertyName.hashCode();
			setPropertyMethod.invoke(myBase, hashCode, thePropertyName, value);
		} catch (Exception e) {
			throw new IllegalStateException(Msg.code(1772) + String.format("Unable to set property %s on %s", thePropertyName, myBase), e);
		}
	}

	/**
	 * Gets property values with the specified name from the provided base class.
	 *
	 * @param thePropertyName Name of the property to get
	 * @return Returns property values converted to string.
	 */
	public List<String> getMultiple(String thePropertyName) {
		Method getPropertyMethod = findGetPropertyMethod(myBase);
		Object[] values;
		try {
			values = (Object[]) getPropertyMethod.invoke(myBase, thePropertyName.hashCode(), thePropertyName, true);
		} catch (Exception e) {
			throw new IllegalStateException(Msg.code(1773) + String.format("Instance %s does not supply property %s", myBase, thePropertyName), e);
		}

		return Arrays.stream(values)
			.map(String::valueOf)
			.filter(s -> !StringUtils.isEmpty(s))
			.collect(Collectors.toList());
	}

	private Method findGetPropertyMethod(IBase theAddress) {
		return getMethod(theAddress, GET_PROPERTY_METHOD_NAME);
	}

	private Method findSetPropertyMethod(IBase theAddress, Class... theParamClasses) {
		return getMethod(theAddress, SET_PROPERTY_METHOD_NAME, theParamClasses);
	}

	/**
	 * Gets the delimiter used when concatenating multiple field values
	 *
	 * @return Returns the delimiter
	 */
	public String getDelimiter() {
		return myDelimiter;
	}

	/**
	 * Sets the delimiter used when concatenating multiple field values
	 *
	 * @param theDelimiter The delimiter to set
	 */
	public void setDelimiter(String theDelimiter) {
		this.myDelimiter = theDelimiter;
	}

	/**
	 * Gets the base instance that this helper operates on
	 *
	 * @return Returns the base instance
	 */
	public IBase getBase() {
		return myBase;
	}
}