Java tutorial
package ca.uhn.fhir.rest.param; /* * #%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 static org.apache.commons.lang3.StringUtils.isBlank; import static org.apache.commons.lang3.StringUtils.isNotBlank; import java.math.BigDecimal; import org.apache.commons.lang3.builder.ToStringBuilder; import org.apache.commons.lang3.builder.ToStringStyle; import org.hl7.fhir.instance.model.api.IBaseResource; import ca.uhn.fhir.context.FhirContext; import ca.uhn.fhir.model.api.IQueryParameterType; import ca.uhn.fhir.model.primitive.IdDt; import ca.uhn.fhir.util.CoverageIgnore; public class ReferenceParam extends BaseParam implements IQueryParameterType { private String myChain; private final IdDt myId = new IdDt(); /** * Constructor */ public ReferenceParam() { super(); } /** * Constructor */ public ReferenceParam(String theValue) { setValueAsQueryToken(null, null, null, theValue); } /** * Constructor */ public ReferenceParam(String theChain, String theValue) { setValueAsQueryToken(null, null, null, theValue); setChain(theChain); } /** * Constructor */ public ReferenceParam(String theResourceType, String theChain, String theValue) { if (isNotBlank(theResourceType)) { setValue(theResourceType + "/" + theValue); } else { setValue(theValue); } setChain(theChain); } @Override String doGetQueryParameterQualifier() { StringBuilder b = new StringBuilder(); if (isNotBlank(getResourceType())) { b.append(':'); b.append(getResourceType()); } if (isNotBlank(myChain)) { b.append('.'); b.append(myChain); } if (b.length() != 0) { return b.toString(); } return null; } @Override String doGetValueAsQueryToken(FhirContext theContext) { if (isBlank(myId.getResourceType())) { return myId.getValue(); // e.g. urn:asdjd or 123 or cid:wieiuru or #1 } else { return myId.getIdPart(); } } @Override void doSetValueAsQueryToken(FhirContext theContext, String theParamName, String theQualifier, String theValue) { String q = theQualifier; String resourceType = null; if (isNotBlank(q)) { if (q.startsWith(":")) { int nextIdx = q.indexOf('.'); if (nextIdx != -1) { resourceType = q.substring(1, nextIdx); myChain = q.substring(nextIdx + 1); } else { resourceType = q.substring(1); } } else if (q.startsWith(".")) { myChain = q.substring(1); } } setValue(theValue); if (isNotBlank(resourceType) && isBlank(getResourceType())) { setValue(resourceType + '/' + theValue); } } @CoverageIgnore public String getBaseUrl() { return myId.getBaseUrl(); } public String getChain() { return myChain; } @CoverageIgnore public String getIdPart() { return myId.getIdPart(); } @CoverageIgnore public BigDecimal getIdPartAsBigDecimal() { return myId.getIdPartAsBigDecimal(); } @CoverageIgnore public Long getIdPartAsLong() { return myId.getIdPartAsLong(); } public String getResourceType() { return myId.getResourceType(); } public Class<? extends IBaseResource> getResourceType(FhirContext theCtx) { if (isBlank(getResourceType())) { return null; } return theCtx.getResourceDefinition(getResourceType()).getImplementingClass(); } public String getValue() { return myId.getValue(); } public boolean hasResourceType() { return myId.hasResourceType(); } @Override protected boolean isSupportsChain() { return true; } public void setChain(String theChain) { myChain = theChain; } public void setValue(String theValue) { myId.setValue(theValue); } /** * Returns a new param containing the same value as this param, but with the type copnverted * to {@link DateParam}. This is useful if you are using reference parameters and want to handle * chained parameters of different types in a single method. * <p> * See <a href="http://jamesagnew.github.io/hapi-fhir/doc_rest_operations.html#dynamic_chains">Dynamic Chains</a> * in the HAPI FHIR documentation for an example of how to use this method. * </p> */ public DateParam toDateParam(FhirContext theContext) { DateParam retVal = new DateParam(); retVal.setValueAsQueryToken(theContext, null, null, getValueAsQueryToken(theContext)); return retVal; } /** * Returns a new param containing the same value as this param, but with the type copnverted * to {@link NumberParam}. This is useful if you are using reference parameters and want to handle * chained parameters of different types in a single method. * <p> * See <a href="http://jamesagnew.github.io/hapi-fhir/doc_rest_operations.html#dynamic_chains">Dynamic Chains</a> * in the HAPI FHIR documentation for an example of how to use this method. * </p> */ public NumberParam toNumberParam(FhirContext theContext) { NumberParam retVal = new NumberParam(); retVal.setValueAsQueryToken(theContext, null, null, getValueAsQueryToken(theContext)); return retVal; } /** * Returns a new param containing the same value as this param, but with the type copnverted * to {@link QuantityParam}. This is useful if you are using reference parameters and want to handle * chained parameters of different types in a single method. * <p> * See <a href="http://jamesagnew.github.io/hapi-fhir/doc_rest_operations.html#dynamic_chains">Dynamic Chains</a> * in the HAPI FHIR documentation for an example of how to use this method. * </p> */ public QuantityParam toQuantityParam(FhirContext theContext) { QuantityParam retVal = new QuantityParam(); retVal.setValueAsQueryToken(theContext, null, null, getValueAsQueryToken(theContext)); return retVal; } @Override public String toString() { ToStringBuilder b = new ToStringBuilder(this, ToStringStyle.SHORT_PREFIX_STYLE); if (isNotBlank(myChain)) { b.append("chain", myChain); } b.append("value", getValue()); return b.build(); } /** * Returns a new param containing the same value as this param, but with the type copnverted * to {@link StringParam}. This is useful if you are using reference parameters and want to handle * chained parameters of different types in a single method. * <p> * See <a href="http://jamesagnew.github.io/hapi-fhir/doc_rest_operations.html#dynamic_chains">Dynamic Chains</a> * in the HAPI FHIR documentation for an example of how to use this method. * </p> */ public StringParam toStringParam(FhirContext theContext) { StringParam retVal = new StringParam(); retVal.setValueAsQueryToken(theContext, null, null, getValueAsQueryToken(theContext)); return retVal; } /** * Returns a new param containing the same value as this param, but with the type copnverted * to {@link TokenParam}. This is useful if you are using reference parameters and want to handle * chained parameters of different types in a single method. * <p> * See <a href="http://jamesagnew.github.io/hapi-fhir/doc_rest_operations.html#dynamic_chains">Dynamic Chains</a> * in the HAPI FHIR documentation for an example of how to use this method. * </p> */ public TokenParam toTokenParam(FhirContext theContext) { TokenParam retVal = new TokenParam(); retVal.setValueAsQueryToken(theContext, null, null, getValueAsQueryToken(theContext)); return retVal; } }