diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/BaseRuntimeDeclaredChildDefinition.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/BaseRuntimeDeclaredChildDefinition.java
index 295e5057660..ffc8d39c3a2 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/BaseRuntimeDeclaredChildDefinition.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/BaseRuntimeDeclaredChildDefinition.java
@@ -34,14 +34,15 @@ import ca.uhn.fhir.util.ValidateUtil;
public abstract class BaseRuntimeDeclaredChildDefinition extends BaseRuntimeChildDefinition {
private final IAccessor myAccessor;
+ private String myBindingValueSet;
private final String myElementName;
private final Field myField;
private final String myFormalDefinition;
private final int myMax;
private final int myMin;
private boolean myModifier;
- private final IMutator myMutator;
+ private final IMutator myMutator;
private final String myShortDefinition;
private boolean mySummary;
BaseRuntimeDeclaredChildDefinition(Field theField, Child theChildAnnotation, Description theDescriptionAnnotation, String theElementName) throws ConfigurationException {
@@ -82,6 +83,10 @@ public abstract class BaseRuntimeDeclaredChildDefinition extends BaseRuntimeChil
return myAccessor;
}
+ public String getBindingValueSet() {
+ return myBindingValueSet;
+ }
+
@Override
public String getElementName() {
return myElementName;
@@ -130,6 +135,10 @@ public abstract class BaseRuntimeDeclaredChildDefinition extends BaseRuntimeChil
return mySummary;
}
+ void setBindingValueSet(String theBindingValueSet) {
+ myBindingValueSet = theBindingValueSet;
+ }
+
protected void setModifier(boolean theModifier) {
myModifier = theModifier;
}
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/BaseRuntimeElementCompositeDefinition.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/BaseRuntimeElementCompositeDefinition.java
index d8e6a27d4f0..45d73f6400a 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/BaseRuntimeElementCompositeDefinition.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/BaseRuntimeElementCompositeDefinition.java
@@ -1,5 +1,7 @@
package ca.uhn.fhir.context;
+import static org.apache.commons.lang3.StringUtils.isNotBlank;
+
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
@@ -45,18 +47,17 @@ import org.hl7.fhir.instance.model.api.IBaseEnumeration;
import org.hl7.fhir.instance.model.api.IBaseExtension;
import org.hl7.fhir.instance.model.api.IBaseReference;
import org.hl7.fhir.instance.model.api.IBaseResource;
-import org.hl7.fhir.instance.model.api.IBaseXhtml;
import org.hl7.fhir.instance.model.api.ICompositeType;
import org.hl7.fhir.instance.model.api.INarrative;
import org.hl7.fhir.instance.model.api.IPrimitiveType;
-import ca.uhn.fhir.model.api.ExtensionDt;
import ca.uhn.fhir.model.api.IBoundCodeableConcept;
import ca.uhn.fhir.model.api.IDatatype;
import ca.uhn.fhir.model.api.IElement;
import ca.uhn.fhir.model.api.IResource;
import ca.uhn.fhir.model.api.IResourceBlock;
import ca.uhn.fhir.model.api.IValueSetEnumBinder;
+import ca.uhn.fhir.model.api.annotation.Binding;
import ca.uhn.fhir.model.api.annotation.Child;
import ca.uhn.fhir.model.api.annotation.ChildOrder;
import ca.uhn.fhir.model.api.annotation.Description;
@@ -245,14 +246,17 @@ public abstract class BaseRuntimeElementCompositeDefinition ext
String elementName = childAnnotation.name();
int order = childAnnotation.order();
boolean childIsChoiceType = false;
+ boolean orderIsReplaceParent = false;
+
if (order == Child.REPLACE_PARENT) {
-
+
if (extensionAttr != null) {
for (Entry nextEntry : orderMap.entrySet()) {
BaseRuntimeDeclaredChildDefinition nextDef = nextEntry.getValue();
if (nextDef instanceof RuntimeChildDeclaredExtensionDefinition) {
if (nextDef.getExtensionUrl().equals(extensionAttr.url())) {
+ orderIsReplaceParent = true;
order = nextEntry.getKey();
orderMap.remove(nextEntry.getKey());
elementNames.remove(elementName);
@@ -270,6 +274,7 @@ public abstract class BaseRuntimeElementCompositeDefinition ext
for (Entry nextEntry : orderMap.entrySet()) {
BaseRuntimeDeclaredChildDefinition nextDef = nextEntry.getValue();
if (elementName.equals(nextDef.getElementName())) {
+ orderIsReplaceParent = true;
order = nextEntry.getKey();
BaseRuntimeDeclaredChildDefinition existing = orderMap.remove(nextEntry.getKey());
elementNames.remove(elementName);
@@ -297,7 +302,8 @@ public abstract class BaseRuntimeElementCompositeDefinition ext
if (order < 0 && order != Child.ORDER_UNKNOWN) {
throw new ConfigurationException("Invalid order '" + order + "' on @Child for field '" + next.getName() + "' on target type: " + theClass);
}
- if (order != Child.ORDER_UNKNOWN) {
+
+ if (order != Child.ORDER_UNKNOWN && !orderIsReplaceParent) {
order = order + baseElementOrder;
}
// int min = childAnnotation.min();
@@ -328,32 +334,25 @@ public abstract class BaseRuntimeElementCompositeDefinition ext
Class> nextElementType = ModelScanner.determineElementType(next);
+ BaseRuntimeDeclaredChildDefinition def;
if (childAnnotation.name().equals("extension") && IBaseExtension.class.isAssignableFrom(nextElementType)) {
- RuntimeChildExtension def = new RuntimeChildExtension(next, childAnnotation.name(), childAnnotation, descriptionAnnotation);
- orderMap.put(order, def);
+ def = new RuntimeChildExtension(next, childAnnotation.name(), childAnnotation, descriptionAnnotation);
} else if (childAnnotation.name().equals("modifierExtension") && IBaseExtension.class.isAssignableFrom(nextElementType)) {
- RuntimeChildExtension def = new RuntimeChildExtension(next, childAnnotation.name(), childAnnotation, descriptionAnnotation);
- orderMap.put(order, def);
+ def = new RuntimeChildExtension(next, childAnnotation.name(), childAnnotation, descriptionAnnotation);
} else if (BaseContainedDt.class.isAssignableFrom(nextElementType) || (childAnnotation.name().equals("contained") && IBaseResource.class.isAssignableFrom(nextElementType))) {
/*
* Child is contained resources
*/
- RuntimeChildContainedResources def = new RuntimeChildContainedResources(next, childAnnotation, descriptionAnnotation, elementName);
- orderMap.put(order, def);
-
+ def = new RuntimeChildContainedResources(next, childAnnotation, descriptionAnnotation, elementName);
} else if (IAnyResource.class.isAssignableFrom(nextElementType) || IResource.class.equals(nextElementType)) {
/*
* Child is a resource as a direct child, as in Bundle.entry.resource
*/
- RuntimeChildDirectResource def = new RuntimeChildDirectResource(next, childAnnotation, descriptionAnnotation, elementName);
- orderMap.put(order, def);
-
+ def = new RuntimeChildDirectResource(next, childAnnotation, descriptionAnnotation, elementName);
} else {
childIsChoiceType |= choiceTypes.size() > 1;
if (childIsChoiceType && !BaseResourceReferenceDt.class.isAssignableFrom(nextElementType) && !IBaseReference.class.isAssignableFrom(nextElementType)) {
- RuntimeChildChoiceDefinition def = new RuntimeChildChoiceDefinition(next, elementName, childAnnotation, descriptionAnnotation, choiceTypes);
- orderMap.put(order, def);
-
+ def = new RuntimeChildChoiceDefinition(next, elementName, childAnnotation, descriptionAnnotation, choiceTypes);
} else if (extensionAttr != null) {
/*
* Child is an extension
@@ -365,14 +364,11 @@ public abstract class BaseRuntimeElementCompositeDefinition ext
binder = ModelScanner.getBoundCodeBinder(next);
}
- RuntimeChildDeclaredExtensionDefinition def = new RuntimeChildDeclaredExtensionDefinition(next, childAnnotation, descriptionAnnotation, extensionAttr, elementName, extensionAttr.url(), et,
- binder);
+ def = new RuntimeChildDeclaredExtensionDefinition(next, childAnnotation, descriptionAnnotation, extensionAttr, elementName, extensionAttr.url(), et, binder);
if (IBaseEnumeration.class.isAssignableFrom(nextElementType)) {
- def.setEnumerationType(ReflectionUtil.getGenericCollectionTypeOfFieldWithSecondOrderForList(next));
+ ((RuntimeChildDeclaredExtensionDefinition)def).setEnumerationType(ReflectionUtil.getGenericCollectionTypeOfFieldWithSecondOrderForList(next));
}
-
- orderMap.put(order, def);
} else if (BaseResourceReferenceDt.class.isAssignableFrom(nextElementType) || IBaseReference.class.isAssignableFrom(nextElementType)) {
/*
* Child is a resource reference
@@ -387,8 +383,7 @@ public abstract class BaseRuntimeElementCompositeDefinition ext
}
refTypesList.add((Class extends IBaseResource>) nextType);
}
- RuntimeChildResourceDefinition def = new RuntimeChildResourceDefinition(next, elementName, childAnnotation, descriptionAnnotation, refTypesList);
- orderMap.put(order, def);
+ def = new RuntimeChildResourceDefinition(next, elementName, childAnnotation, descriptionAnnotation, refTypesList);
} else if (IResourceBlock.class.isAssignableFrom(nextElementType) || IBaseBackboneElement.class.isAssignableFrom(nextElementType)
|| IBaseDatatypeElement.class.isAssignableFrom(nextElementType)) {
@@ -397,20 +392,15 @@ public abstract class BaseRuntimeElementCompositeDefinition ext
*/
Class extends IBase> blockDef = (Class extends IBase>) nextElementType;
- RuntimeChildResourceBlockDefinition def = new RuntimeChildResourceBlockDefinition(myContext, next, childAnnotation, descriptionAnnotation, elementName, blockDef);
- orderMap.put(order, def);
-
+ def = new RuntimeChildResourceBlockDefinition(myContext, next, childAnnotation, descriptionAnnotation, elementName, blockDef);
} else if (IDatatype.class.equals(nextElementType) || IElement.class.equals(nextElementType) || "Type".equals(nextElementType.getSimpleName())
|| IBaseDatatype.class.equals(nextElementType)) {
- RuntimeChildAny def = new RuntimeChildAny(next, elementName, childAnnotation, descriptionAnnotation);
- orderMap.put(order, def);
-
+ def = new RuntimeChildAny(next, elementName, childAnnotation, descriptionAnnotation);
} else if (IDatatype.class.isAssignableFrom(nextElementType) || IPrimitiveType.class.isAssignableFrom(nextElementType) || ICompositeType.class.isAssignableFrom(nextElementType)
|| IBaseDatatype.class.isAssignableFrom(nextElementType) || IBaseExtension.class.isAssignableFrom(nextElementType)) {
Class extends IBase> nextDatatype = (Class extends IBase>) nextElementType;
- BaseRuntimeChildDatatypeDefinition def;
if (IPrimitiveType.class.isAssignableFrom(nextElementType)) {
if (nextElementType.equals(BoundCodeDt.class)) {
IValueSetEnumBinder> binder = ModelScanner.getBoundCodeBinder(next);
@@ -434,13 +424,20 @@ public abstract class BaseRuntimeElementCompositeDefinition ext
}
}
- orderMap.put(order, def);
-
} else {
throw new ConfigurationException("Field '" + elementName + "' in type '" + theClass.getCanonicalName() + "' is not a valid child type: " + nextElementType);
}
+
+ Binding bindingAnnotation = ModelScanner.pullAnnotation(next, Binding.class);
+ if (bindingAnnotation != null) {
+ if (isNotBlank(bindingAnnotation.valueSet())) {
+ def.setBindingValueSet(bindingAnnotation.valueSet());
+ }
+ }
+
}
+ orderMap.put(order, def);
elementNames.add(elementName);
}
}
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/ModelScanner.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/ModelScanner.java
index e51a7d198bc..5f402f6fa7f 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/ModelScanner.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/context/ModelScanner.java
@@ -112,13 +112,6 @@ class ModelScanner {
init(theExistingDefinitions, toScan);
}
- private void addScanAlso(Class extends IBase> theType) {
- if (theType.isInterface() || Modifier.isAbstract(theType.getModifiers())) {
- return;
- }
- myScanAlso.add(theType);
- }
-
static Class> determineElementType(Field next) {
Class> nextElementType = next.getType();
if (List.class.equals(nextElementType)) {
@@ -310,12 +303,6 @@ class ModelScanner {
RuntimeResourceBlockDefinition blockDef = new RuntimeResourceBlockDefinition(resourceName, theClass, isStandardType(theClass), myContext, myClassToElementDefinitions);
myClassToElementDefinitions.put(theClass, blockDef);
-
- scanCompositeElementForChildren(theClass, blockDef);
- }
-
- private void scanCompositeElementForChildren(Class extends IBase> theClass, Object theBlockDef) {
- // TODO remove
}
private void scanCompositeDatatype(Class extends ICompositeType> theClass, DatatypeDef theDatatypeDefinition) {
@@ -331,7 +318,6 @@ class ModelScanner {
}
myClassToElementDefinitions.put(theClass, elementDef);
myNameToElementDefinitions.put(elementDef.getName().toLowerCase(), elementDef);
- scanCompositeElementForChildren(theClass, elementDef);
}
@@ -422,7 +408,6 @@ class ModelScanner {
myNameToResourceDefinitions.put(resourceName.toLowerCase(), resourceDef);
}
}
- scanCompositeElementForChildren(theClass, resourceDef);
myIdToResourceDefinition.put(resourceId, resourceDef);
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/model/api/annotation/Binding.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/model/api/annotation/Binding.java
new file mode 100644
index 00000000000..4278cbb08fd
--- /dev/null
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/model/api/annotation/Binding.java
@@ -0,0 +1,39 @@
+package ca.uhn.fhir.model.api.annotation;
+
+/*
+ * #%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.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * Field annotation for fields which are bound to a given valueset
+ */
+@Retention(RetentionPolicy.RUNTIME)
+@Target(value = { ElementType.FIELD })
+public @interface Binding {
+
+ /**
+ * The canonical URL of the valueset
+ */
+ String valueSet();
+}
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/model/primitive/BaseDateTimeDt.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/model/primitive/BaseDateTimeDt.java
index 5b4f001a5f8..4b9be10bbf6 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/model/primitive/BaseDateTimeDt.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/model/primitive/BaseDateTimeDt.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.model.primitive;
+/*
+ * #%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 java.util.Calendar;
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/AtParameter.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/AtParameter.java
index 14bc023553e..03cf6b10bbf 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/AtParameter.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/AtParameter.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.method;
+/*
+ * #%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 ca.uhn.fhir.rest.annotation.At;
import ca.uhn.fhir.rest.server.Constants;
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/BaseJavaPrimitiveBinder.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/BaseJavaPrimitiveBinder.java
index 35fc2b1ecbf..074ec2ebdf4 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/BaseJavaPrimitiveBinder.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/BaseJavaPrimitiveBinder.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.method;
+/*
+ * #%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 java.util.Collections;
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/CalendarBinder.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/CalendarBinder.java
index a8c8a804fc4..787b076d3d9 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/CalendarBinder.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/CalendarBinder.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.method;
+/*
+ * #%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.Calendar;
import ca.uhn.fhir.model.primitive.InstantDt;
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/DateBinder.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/DateBinder.java
index 6fbe70982f1..1b7f46062d2 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/DateBinder.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/DateBinder.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.method;
+/*
+ * #%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.Date;
import ca.uhn.fhir.model.primitive.InstantDt;
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/FhirPrimitiveBinder.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/FhirPrimitiveBinder.java
index c6cbb90d76f..320997c66c9 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/FhirPrimitiveBinder.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/FhirPrimitiveBinder.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.method;
+/*
+ * #%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.defaultString;
import org.hl7.fhir.instance.model.api.IPrimitiveType;
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/SinceParameter.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/SinceParameter.java
index fd540949917..b526207770f 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/SinceParameter.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/SinceParameter.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.method;
+/*
+ * #%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 ca.uhn.fhir.rest.annotation.Since;
import ca.uhn.fhir.rest.server.Constants;
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/StringBinder.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/StringBinder.java
index d6d9dde5afd..1dece004619 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/StringBinder.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/method/StringBinder.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.method;
+/*
+ * #%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%
+ */
+
final class StringBinder extends BaseJavaPrimitiveBinder {
StringBinder() {
}
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/VerboseLoggingInterceptor.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/VerboseLoggingInterceptor.java
index b14f1f56cef..9df355891fb 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/VerboseLoggingInterceptor.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/VerboseLoggingInterceptor.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.server.interceptor;
+/*
+ * #%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.Enumeration;
import javax.servlet.http.HttpServletRequest;
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/BaseRule.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/BaseRule.java
index 08a75b82092..b874b253d75 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/BaseRule.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/BaseRule.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.server.interceptor.auth;
+/*
+ * #%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 ca.uhn.fhir.rest.server.interceptor.auth.AuthorizationInterceptor.Verdict;
abstract class BaseRule implements IAuthRule {
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/IAuthRuleBuilderOperation.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/IAuthRuleBuilderOperation.java
index 20c11bde773..7593ac753a9 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/IAuthRuleBuilderOperation.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/IAuthRuleBuilderOperation.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.server.interceptor.auth;
+/*
+ * #%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%
+ */
+
public interface IAuthRuleBuilderOperation {
/**
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/IAuthRuleBuilderOperationNamed.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/IAuthRuleBuilderOperationNamed.java
index 49ca0e483a2..eb783673b03 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/IAuthRuleBuilderOperationNamed.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/IAuthRuleBuilderOperationNamed.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.server.interceptor.auth;
+/*
+ * #%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 org.hl7.fhir.instance.model.api.IBaseResource;
import org.hl7.fhir.instance.model.api.IIdType;
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/OperationRule.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/OperationRule.java
index a4581cb4710..1e97a1b0c6d 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/OperationRule.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/rest/server/interceptor/auth/OperationRule.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.rest.server.interceptor.auth;
+/*
+ * #%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.HashSet;
import java.util.List;
diff --git a/hapi-fhir-base/src/main/java/ca/uhn/fhir/util/PortUtil.java b/hapi-fhir-base/src/main/java/ca/uhn/fhir/util/PortUtil.java
index 7ac653d5286..25cc450e961 100644
--- a/hapi-fhir-base/src/main/java/ca/uhn/fhir/util/PortUtil.java
+++ b/hapi-fhir-base/src/main/java/ca/uhn/fhir/util/PortUtil.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.util;
+/*
+ * #%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.net.ServerSocket;
/**
diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/dao/SearchBuilder.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/dao/SearchBuilder.java
index 6a5b2f80303..da7d76ee4e1 100644
--- a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/dao/SearchBuilder.java
+++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/dao/SearchBuilder.java
@@ -71,6 +71,8 @@ import com.google.common.collect.Lists;
import com.google.common.collect.Sets;
import ca.uhn.fhir.context.BaseRuntimeChildDefinition;
+import ca.uhn.fhir.context.BaseRuntimeDeclaredChildDefinition;
+import ca.uhn.fhir.context.BaseRuntimeElementDefinition;
import ca.uhn.fhir.context.ConfigurationException;
import ca.uhn.fhir.context.FhirContext;
import ca.uhn.fhir.context.FhirVersionEnum;
@@ -1379,8 +1381,10 @@ public class SearchBuilder {
if (modifier == TokenParamModifier.IN) {
codes = myTerminologySvc.expandValueSet(code);
} else if (modifier == TokenParamModifier.ABOVE) {
+ system = determineSystemIfMissing(theParamName, code, system);
codes = myTerminologySvc.findCodesAbove(system, code);
} else if (modifier == TokenParamModifier.BELOW) {
+ system = determineSystemIfMissing(theParamName, code, system);
codes = myTerminologySvc.findCodesBelow(system, code);
}
@@ -1428,6 +1432,34 @@ public class SearchBuilder {
return singleCode;
}
+ private String determineSystemIfMissing(String theParamName, String code, String system) {
+ if (system == null) {
+ RuntimeSearchParam param = getSearchParam(theParamName);
+ if (param != null) {
+ Set valueSetUris = Sets.newHashSet();
+ for (String nextPath : param.getPathsSplit()) {
+ BaseRuntimeChildDefinition def = myContext.newTerser().getDefinition(myResourceType, nextPath);
+ if (def instanceof BaseRuntimeDeclaredChildDefinition) {
+ String valueSet = ((BaseRuntimeDeclaredChildDefinition) def).getBindingValueSet();
+ if (isNotBlank(valueSet)) {
+ valueSetUris.add(valueSet);
+ }
+ }
+ }
+ if (valueSetUris.size() == 1) {
+ List candidateCodes = myTerminologySvc.expandValueSet(valueSetUris.iterator().next());
+ for (VersionIndependentConcept nextCandidate : candidateCodes) {
+ if (nextCandidate.getCode().equals(code)) {
+ system = nextCandidate.getSystem();
+ break;
+ }
+ }
+ }
+ }
+ }
+ return system;
+ }
+
private Predicate createResourceLinkPathPredicate(String theParamName, Root extends ResourceLink> from) {
return createResourceLinkPathPredicate(myContext, theParamName, from, myResourceType);
}
@@ -1488,8 +1520,7 @@ public class SearchBuilder {
return;
}
- RuntimeResourceDefinition resourceDef = myContext.getResourceDefinition(myResourceType);
- RuntimeSearchParam param = resourceDef.getSearchParam(theSort.getParamName());
+ RuntimeSearchParam param = getSearchParam(theSort.getParamName());
if (param == null) {
throw new InvalidRequestException("Unknown sort parameter '" + theSort.getParamName() + "'");
}
@@ -1553,6 +1584,12 @@ public class SearchBuilder {
createSort(theBuilder, theFrom, theSort.getChain(), theOrders, thePredicates);
}
+ private RuntimeSearchParam getSearchParam(String theParamName) {
+ RuntimeResourceDefinition resourceDef = myContext.getResourceDefinition(myResourceType);
+ RuntimeSearchParam param = resourceDef.getSearchParam(theParamName);
+ return param;
+ }
+
public Set doGetPids() {
if (myParams.isPersistResults()) {
HashSet retVal = new HashSet();
diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoValueSetDstu3.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoValueSetDstu3.java
index ac9092beaef..249a7516b96 100644
--- a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoValueSetDstu3.java
+++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoValueSetDstu3.java
@@ -23,21 +23,15 @@ package ca.uhn.fhir.jpa.dao.dstu3;
import static org.apache.commons.lang3.StringUtils.isBlank;
import static org.apache.commons.lang3.StringUtils.isNotBlank;
-import java.nio.file.FileVisitOption;
import java.util.ArrayList;
import java.util.Collections;
-import java.util.Date;
-import java.util.Iterator;
import java.util.List;
import java.util.Set;
import org.apache.commons.codec.binary.StringUtils;
-import org.hl7.fhir.dstu3.exceptions.TerminologyServiceException;
import org.hl7.fhir.dstu3.hapi.validation.HapiWorkerContext;
import org.hl7.fhir.dstu3.hapi.validation.IValidationSupport;
-import org.hl7.fhir.dstu3.hapi.validation.IValidationSupport.CodeValidationResult;
import org.hl7.fhir.dstu3.model.CodeSystem;
-import org.hl7.fhir.dstu3.model.CodeSystem.ConceptDefinitionComponent;
import org.hl7.fhir.dstu3.model.CodeableConcept;
import org.hl7.fhir.dstu3.model.Coding;
import org.hl7.fhir.dstu3.model.IdType;
@@ -46,7 +40,6 @@ import org.hl7.fhir.dstu3.model.ValueSet;
import org.hl7.fhir.dstu3.model.ValueSet.ConceptSetComponent;
import org.hl7.fhir.dstu3.model.ValueSet.ConceptSetFilterComponent;
import org.hl7.fhir.dstu3.model.ValueSet.FilterOperator;
-import org.hl7.fhir.dstu3.model.ValueSet.ValueSetExpansionComponent;
import org.hl7.fhir.dstu3.model.ValueSet.ValueSetExpansionContainsComponent;
import org.hl7.fhir.dstu3.terminologies.ValueSetExpander.ValueSetExpansionOutcome;
import org.hl7.fhir.instance.model.api.IIdType;
@@ -86,12 +79,14 @@ public class FhirResourceDaoValueSetDstu3 extends FhirResourceDaoDstu3
HapiWorkerContext workerContext = new HapiWorkerContext(getContext(), myValidationSupport);
ValueSetExpansionOutcome outcome = workerContext.expand(theSource);
- ValueSetExpansionComponent expansion = outcome.getValueset().getExpansion();
-
- ValueSet retVal = new ValueSet();
- retVal.getMeta().setLastUpdated(new Date());
- retVal.setExpansion(expansion);
- return retVal;
+ return outcome.getValueset();
+
+// ValueSetExpansionComponent expansion = outcome.getValueset().getExpansion();
+//
+// ValueSet retVal = new ValueSet();
+// retVal.getMeta().setLastUpdated(new Date());
+// retVal.setExpansion(expansion);
+// return retVal;
}
private void validateIncludes(String name, List listToValidate) {
diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/provider/BaseJpaSystemProviderDstu2Plus.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/provider/BaseJpaSystemProviderDstu2Plus.java
index cadce02eaba..e8db8a5d253 100644
--- a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/provider/BaseJpaSystemProviderDstu2Plus.java
+++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/provider/BaseJpaSystemProviderDstu2Plus.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.jpa.provider;
+/*
+ * #%L
+ * HAPI FHIR JPA Server
+ * %%
+ * 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 org.hl7.fhir.instance.model.api.IBaseParameters;
import org.hl7.fhir.instance.model.api.IBaseResource;
import org.hl7.fhir.instance.model.api.IPrimitiveType;
diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/search/DeferConceptIndexingInterceptor.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/search/DeferConceptIndexingInterceptor.java
index 405016638bf..03c31bac0cc 100644
--- a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/search/DeferConceptIndexingInterceptor.java
+++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/search/DeferConceptIndexingInterceptor.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.jpa.search;
+/*
+ * #%L
+ * HAPI FHIR JPA Server
+ * %%
+ * 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 org.hibernate.search.indexes.interceptor.EntityIndexingInterceptor;
import org.hibernate.search.indexes.interceptor.IndexingOverride;
diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/term/HapiTerminologySvcDstu3.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/term/HapiTerminologySvcDstu3.java
index 46e0586b6ab..515c053a57d 100644
--- a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/term/HapiTerminologySvcDstu3.java
+++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/term/HapiTerminologySvcDstu3.java
@@ -64,6 +64,7 @@ import ca.uhn.fhir.jpa.entity.TermCodeSystem;
import ca.uhn.fhir.jpa.entity.TermCodeSystemVersion;
import ca.uhn.fhir.jpa.entity.TermConcept;
import ca.uhn.fhir.rest.method.RequestDetails;
+import ca.uhn.fhir.rest.server.exceptions.BaseServerResponseException;
import ca.uhn.fhir.rest.server.exceptions.InternalErrorException;
import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException;
import ca.uhn.fhir.util.CoverageIgnore;
@@ -278,6 +279,8 @@ public class HapiTerminologySvcDstu3 extends BaseHapiTerminologySvc implements I
return retVal;
+ } catch (BaseServerResponseException e) {
+ throw e;
} catch (Exception e) {
throw new InternalErrorException(e);
}
diff --git a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/util/Counter.java b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/util/Counter.java
index f0552bf25cf..513c5cb48d1 100644
--- a/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/util/Counter.java
+++ b/hapi-fhir-jpaserver-base/src/main/java/ca/uhn/fhir/jpa/util/Counter.java
@@ -1,5 +1,25 @@
package ca.uhn.fhir.jpa.util;
+/*
+ * #%L
+ * HAPI FHIR JPA Server
+ * %%
+ * 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%
+ */
+
public class Counter {
private long myCount;
diff --git a/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3SearchNoFtTest.java b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3SearchNoFtTest.java
index 5d20430896e..8cefe75577d 100644
--- a/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3SearchNoFtTest.java
+++ b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3SearchNoFtTest.java
@@ -29,13 +29,13 @@ import org.hl7.fhir.dstu3.model.CodeableConcept;
import org.hl7.fhir.dstu3.model.Coding;
import org.hl7.fhir.dstu3.model.ConceptMap;
import org.hl7.fhir.dstu3.model.ContactPoint.ContactPointSystem;
-import org.hl7.fhir.dstu3.model.Enumerations.AdministrativeGender;
import org.hl7.fhir.dstu3.model.DateTimeType;
import org.hl7.fhir.dstu3.model.DateType;
import org.hl7.fhir.dstu3.model.Device;
import org.hl7.fhir.dstu3.model.DiagnosticOrder;
import org.hl7.fhir.dstu3.model.DiagnosticReport;
import org.hl7.fhir.dstu3.model.Encounter;
+import org.hl7.fhir.dstu3.model.Enumerations.AdministrativeGender;
import org.hl7.fhir.dstu3.model.IdType;
import org.hl7.fhir.dstu3.model.Immunization;
import org.hl7.fhir.dstu3.model.Location;
@@ -74,8 +74,6 @@ import ca.uhn.fhir.jpa.entity.ResourceLink;
import ca.uhn.fhir.model.api.IQueryParameterType;
import ca.uhn.fhir.model.api.Include;
import ca.uhn.fhir.model.dstu.valueset.QuantityCompararatorEnum;
-import ca.uhn.fhir.model.dstu2.composite.PeriodDt;
-import ca.uhn.fhir.model.primitive.DateTimeDt;
import ca.uhn.fhir.rest.api.SortOrderEnum;
import ca.uhn.fhir.rest.api.SortSpec;
import ca.uhn.fhir.rest.param.CompositeParam;
@@ -98,7 +96,6 @@ import ca.uhn.fhir.rest.param.UriParamQualifierEnum;
import ca.uhn.fhir.rest.server.Constants;
import ca.uhn.fhir.rest.server.IBundleProvider;
import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException;
-import ca.uhn.fhir.rest.server.exceptions.ResourceNotFoundException;
import ca.uhn.fhir.util.TestUtil;
@SuppressWarnings("unchecked")
@@ -291,10 +288,10 @@ public class FhirResourceDaoDstu3SearchNoFtTest extends BaseJpaDstu3Test {
@Test
public void testIndexNoDuplicatesUri() {
ConceptMap res = new ConceptMap();
- res.addElement().addTarget().addDependsOn().setElement("http://foo");
- res.addElement().addTarget().addDependsOn().setElement("http://foo");
- res.addElement().addTarget().addDependsOn().setElement("http://bar");
- res.addElement().addTarget().addDependsOn().setElement("http://bar");
+ res.addGroup().setSource("http://foo");
+ res.addGroup().setSource("http://foo");
+ res.addGroup().setSource("http://bar");
+ res.addGroup().setSource("http://bar");
IIdType id = myConceptMapDao.create(res, mySrd).getId().toUnqualifiedVersionless();
diff --git a/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3TerminologyTest.java b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3TerminologyTest.java
index 9b63a2eb23e..9d93a485fa5 100644
--- a/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3TerminologyTest.java
+++ b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3TerminologyTest.java
@@ -36,11 +36,14 @@ import ca.uhn.fhir.jpa.entity.ResourceTable;
import ca.uhn.fhir.jpa.entity.TermCodeSystemVersion;
import ca.uhn.fhir.jpa.entity.TermConcept;
import ca.uhn.fhir.jpa.entity.TermConceptParentChildLink.RelationshipTypeEnum;
+import ca.uhn.fhir.parser.IParser;
import ca.uhn.fhir.rest.param.TokenParam;
import ca.uhn.fhir.rest.param.TokenParamModifier;
import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException;
import ca.uhn.fhir.rest.server.exceptions.UnprocessableEntityException;
import ca.uhn.fhir.util.TestUtil;
+import ca.uhn.fhir.validation.FhirValidator;
+import ca.uhn.fhir.validation.ValidationResult;
public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
@@ -53,7 +56,6 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
myDaoConfig.setDeferIndexingForCodesystemsOfSize(new DaoConfig().getDeferIndexingForCodesystemsOfSize());
}
-
@Before
public void before() {
myDaoConfig.setMaximumExpansionSize(5000);
@@ -130,7 +132,6 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
createLocalVs(codeSystem);
}
-
private void createLocalVs(CodeSystem codeSystem) {
ValueSet valueSet = new ValueSet();
valueSet.setUrl(URL_MY_VALUE_SET);
@@ -138,17 +139,16 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
myValueSetDao.create(valueSet, mySrd);
}
-
@Test
public void testCodeSystemCreateDuplicateFails() {
CodeSystem codeSystem = new CodeSystem();
codeSystem.setUrl(URL_MY_CODE_SYSTEM);
- codeSystem.setContent(CodeSystemContentMode.COMPLETE);
+ codeSystem.setContent(CodeSystemContentMode.COMPLETE);
IIdType id = myCodeSystemDao.create(codeSystem, mySrd).getId().toUnqualified();
codeSystem = new CodeSystem();
codeSystem.setUrl(URL_MY_CODE_SYSTEM);
- codeSystem.setContent(CodeSystemContentMode.COMPLETE);
+ codeSystem.setContent(CodeSystemContentMode.COMPLETE);
try {
myCodeSystemDao.create(codeSystem, mySrd);
fail();
@@ -172,14 +172,14 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
.addConcept(new ConceptDefinitionComponent().setCode("BA").setDisplay("Code AA"))
.addConcept(new ConceptDefinitionComponent().setCode("BB").setDisplay("Code AB"));
//@formatter:on
-
+
IIdType id = myCodeSystemDao.create(codeSystem, mySrd).getId().toUnqualified();
-
+
Set codes = myTermSvc.findCodesBelow(id.getIdPartAsLong(), id.getVersionIdPartAsLong(), "A");
assertThat(toCodes(codes), containsInAnyOrder("A", "AA", "AB"));
-
+
}
-
+
@Test
public void testExpandWithExcludeInExternalValueSet() {
createExternalCsAndLocalVs();
@@ -192,16 +192,30 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
exclude.setSystem(URL_MY_CODE_SYSTEM);
exclude.addConcept().setCode("childAA");
exclude.addConcept().setCode("childAAA");
-
+
ValueSet result = myValueSetDao.expand(vs, null);
-
- String encoded = myFhirCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(result);
- ourLog.info(encoded);
-
+ logAndValidateValueSet(result);
+
ArrayList codes = toCodesContains(result.getExpansion().getContains());
assertThat(codes, containsInAnyOrder("ParentA", "ParentB", "childAB", "childAAB", "ParentC", "childBA", "childCA"));
}
+ private void logAndValidateValueSet(ValueSet theResult) {
+ IParser parser = myFhirCtx.newXmlParser().setPrettyPrint(true);
+ String encoded = parser.encodeResourceToString(theResult);
+ ourLog.info(encoded);
+
+ FhirValidator validator = myFhirCtx.newValidator();
+ validator.setValidateAgainstStandardSchema(true);
+ validator.setValidateAgainstStandardSchematron(true);
+ ValidationResult result = validator.validateWithResult(theResult);
+
+ if (!result.isSuccessful()) {
+ ourLog.info(parser.encodeResourceToString(result.toOperationOutcome()));
+ fail(parser.encodeResourceToString(result.toOperationOutcome()));
+ }
+ }
+
@Test
public void testExpandWithInvalidExclude() {
createExternalCsAndLocalVs();
@@ -239,7 +253,7 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
} catch (InvalidRequestException e) {
assertEquals("Unable to find code 'ZZZZ' in code system http://example.com/my_code_system", e.getMessage());
}
-
+
}
@Test
@@ -259,10 +273,8 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
}
}
-
-
@Test
- public void testExpandWithSystemAndCodesAndFilterInExternalValueSet() {
+ public void testExpandWithSystemAndCodesInExternalValueSet() {
createExternalCsAndLocalVs();
ValueSet vs = new ValueSet();
@@ -272,22 +284,36 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
include.addConcept().setCode("childAA");
include.addConcept().setCode("childAAA");
- include.addFilter().setProperty("display").setOp(FilterOperator.EQUAL).setValue("Parent B");
-
ValueSet result = myValueSetDao.expand(vs, null);
-
- String encoded = myFhirCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(result);
- ourLog.info(encoded);
-
+ logAndValidateValueSet(result);
+
ArrayList codes = toCodesContains(result.getExpansion().getContains());
- assertThat(codes, containsInAnyOrder("ParentA", "childAA", "childAAA", "ParentB"));
-
+ assertThat(codes, containsInAnyOrder("ParentA", "childAA", "childAAA"));
+
int idx = codes.indexOf("childAA");
assertEquals("childAA", result.getExpansion().getContains().get(idx).getCode());
assertEquals("Child AA", result.getExpansion().getContains().get(idx).getDisplay());
assertEquals(URL_MY_CODE_SYSTEM, result.getExpansion().getContains().get(idx).getSystem());
}
+ @Test
+ public void testExpandWithSystemAndFilterInExternalValueSet() {
+ createExternalCsAndLocalVs();
+
+ ValueSet vs = new ValueSet();
+ ConceptSetComponent include = vs.getCompose().addInclude();
+ include.setSystem(URL_MY_CODE_SYSTEM);
+
+ include.addFilter().setProperty("display").setOp(FilterOperator.EQUAL).setValue("Parent B");
+
+ ValueSet result = myValueSetDao.expand(vs, null);
+ logAndValidateValueSet(result);
+
+ ArrayList codes = toCodesContains(result.getExpansion().getContains());
+ assertThat(codes, containsInAnyOrder("ParentB"));
+
+ }
+
@Test
public void testExpandWithDisplayInExternalValueSetFuzzyMatching() {
createExternalCsAndLocalVs();
@@ -297,8 +323,7 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
include.setSystem(URL_MY_CODE_SYSTEM);
include.addFilter().setProperty("display").setOp(FilterOperator.EQUAL).setValue("parent a");
ValueSet result = myValueSetDao.expand(vs, null);
- String encoded = myFhirCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(result);
- ourLog.info(encoded);
+ logAndValidateValueSet(result);
ArrayList codes = toCodesContains(result.getExpansion().getContains());
assertThat(codes, containsInAnyOrder("ParentA"));
@@ -307,8 +332,7 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
include.setSystem(URL_MY_CODE_SYSTEM);
include.addFilter().setProperty("display").setOp(FilterOperator.EQUAL).setValue("pare");
result = myValueSetDao.expand(vs, null);
- encoded = myFhirCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(result);
- ourLog.info(encoded);
+ logAndValidateValueSet(result);
codes = toCodesContains(result.getExpansion().getContains());
assertThat(codes, containsInAnyOrder("ParentA", "ParentB", "ParentC"));
@@ -317,8 +341,7 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
include.setSystem(URL_MY_CODE_SYSTEM);
include.addFilter().setProperty("display:exact").setOp(FilterOperator.EQUAL).setValue("pare");
result = myValueSetDao.expand(vs, null);
- encoded = myFhirCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(result);
- ourLog.info(encoded);
+ logAndValidateValueSet(result);
codes = toCodesContains(result.getExpansion().getContains());
assertThat(codes, empty());
@@ -332,25 +355,20 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
ConceptSetComponent include = vs.getCompose().addInclude();
include.setSystem(URL_MY_CODE_SYSTEM);
include.addConcept().setCode("A");
-// include.addConcept().setCode("AA");
-// include.addConcept().setCode("AAA");
-// include.addConcept().setCode("AB");
include.addFilter().setProperty("display").setOp(FilterOperator.EQUAL).setValue("AAA");
-
+
ValueSet result = myValueSetDao.expand(vs, null);
-
- String encoded = myFhirCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(result);
- ourLog.info(encoded);
-
+ logAndValidateValueSet(result);
+
ArrayList codes = toCodesContains(result.getExpansion().getContains());
assertThat(codes, containsInAnyOrder("A", "AAA"));
-
+
int idx = codes.indexOf("AAA");
assertEquals("AAA", result.getExpansion().getContains().get(idx).getCode());
assertEquals("Code AAA", result.getExpansion().getContains().get(idx).getDisplay());
assertEquals(URL_MY_CODE_SYSTEM, result.getExpansion().getContains().get(idx).getSystem());
-//
+ //
}
@Test
@@ -364,43 +382,40 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
include.addConcept().setCode("AA");
include.addConcept().setCode("AAA");
include.addConcept().setCode("AB");
-
+
ValueSet result = myValueSetDao.expand(vs, null);
-
- String encoded = myFhirCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(result);
- ourLog.info(encoded);
-
+ logAndValidateValueSet(result);
+
ArrayList codes = toCodesContains(result.getExpansion().getContains());
assertThat(codes, containsInAnyOrder("A", "AA", "AAA", "AB"));
-
+
int idx = codes.indexOf("AAA");
assertEquals("AAA", result.getExpansion().getContains().get(idx).getCode());
assertEquals("Code AAA", result.getExpansion().getContains().get(idx).getDisplay());
assertEquals(URL_MY_CODE_SYSTEM, result.getExpansion().getContains().get(idx).getSystem());
-// ValueSet expansion = myValueSetDao.expandByIdentifier(URL_MY_VALUE_SET, "cervical");
-// ValueSet expansion = myValueSetDao.expandByIdentifier(URL_MY_VALUE_SET, "cervical");
-//
+ // ValueSet expansion = myValueSetDao.expandByIdentifier(URL_MY_VALUE_SET, "cervical");
+ // ValueSet expansion = myValueSetDao.expandByIdentifier(URL_MY_VALUE_SET, "cervical");
+ //
}
@Test
public void testIndexingIsDeferredForLargeCodeSystems() {
myDaoConfig.setDeferIndexingForCodesystemsOfSize(1);
-
+
myTermSvc.setProcessDeferred(false);
-
+
createExternalCsAndLocalVs();
ValueSet vs = new ValueSet();
ConceptSetComponent include = vs.getCompose().addInclude();
include.setSystem(URL_MY_CODE_SYSTEM);
include.addFilter().setProperty("concept").setOp(FilterOperator.ISA).setValue("ParentA");
-
+
ValueSet result = myValueSetDao.expand(vs, null);
- String encoded = myFhirCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(result);
- ourLog.info(encoded);
-
+ logAndValidateValueSet(result);
+
assertEquals(0, result.getExpansion().getContains().size());
-
+
myTermSvc.setProcessDeferred(true);
myTermSvc.saveDeferred();
myTermSvc.saveDeferred();
@@ -409,29 +424,29 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
myTermSvc.saveDeferred();
myTermSvc.saveDeferred();
myTermSvc.saveDeferred();
-
+
vs = new ValueSet();
include = vs.getCompose().addInclude();
include.setSystem(URL_MY_CODE_SYSTEM);
include.addFilter().setProperty("concept").setOp(FilterOperator.ISA).setValue("ParentA");
result = myValueSetDao.expand(vs, null);
- encoded = myFhirCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(result);
- ourLog.info(encoded);
-
+ logAndValidateValueSet(result);
+
assertEquals(4, result.getExpansion().getContains().size());
+ String encoded = myFhirCtx.newXmlParser().setPrettyPrint(true).encodeResourceToString(result);
assertThat(encoded, containsStringIgnoringCase(""));
}
/**
- * Can't currently abort costly
+ * Can't currently abort costly
*/
@Test
@Ignore
public void testRefuseCostlyExpansionFhirCodesystem() {
createLocalCsAndVs();
myDaoConfig.setMaximumExpansionSize(1);
-
+
SearchParameterMap params = new SearchParameterMap();
params.add(AuditEvent.SP_TYPE, new TokenParam(null, "http://hl7.org/fhir/ValueSet/audit-event-type").setModifier(TokenParamModifier.IN));
try {
@@ -446,7 +461,7 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
public void testRefuseCostlyExpansionLocalCodesystem() {
createLocalCsAndVs();
myDaoConfig.setMaximumExpansionSize(1);
-
+
SearchParameterMap params = new SearchParameterMap();
params.add(Observation.SP_CODE, new TokenParam(URL_MY_CODE_SYSTEM, "AAA").setModifier(TokenParamModifier.ABOVE));
try {
@@ -460,7 +475,7 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
@Test
public void testSearchCodeAboveLocalCodesystem() {
createLocalCsAndVs();
-
+
Observation obsAA = new Observation();
obsAA.getCode().addCoding().setSystem(URL_MY_CODE_SYSTEM).setCode("AA");
IIdType idAA = myObservationDao.create(obsAA, mySrd).getId().toUnqualifiedVersionless();
@@ -476,18 +491,18 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
SearchParameterMap params = new SearchParameterMap();
params.add(Observation.SP_CODE, new TokenParam(URL_MY_CODE_SYSTEM, "AAA").setModifier(TokenParamModifier.ABOVE));
assertThat(toUnqualifiedVersionlessIdValues(myObservationDao.search(params)), containsInAnyOrder(idAA.getValue()));
-
+
params = new SearchParameterMap();
params.add(Observation.SP_CODE, new TokenParam(URL_MY_CODE_SYSTEM, "A").setModifier(TokenParamModifier.ABOVE));
assertThat(toUnqualifiedVersionlessIdValues(myObservationDao.search(params)), empty());
-
+
}
@Test
public void testSearchCodeBelowAndAboveUnknownCodeSystem() {
SearchParameterMap params = new SearchParameterMap();
-
+
params.add(Observation.SP_CODE, new TokenParam(URL_MY_CODE_SYSTEM, "childAA").setModifier(TokenParamModifier.BELOW));
assertThat(toUnqualifiedVersionlessIdValues(myObservationDao.search(params)), empty());
@@ -496,14 +511,13 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
params.add(Observation.SP_CODE, new TokenParam(null, URL_MY_VALUE_SET).setModifier(TokenParamModifier.IN));
assertThat(toUnqualifiedVersionlessIdValues(myObservationDao.search(params)), empty());
-
- }
+ }
@Test
public void testSearchCodeBelowLocalCodesystem() {
createLocalCsAndVs();
-
+
Observation obsAA = new Observation();
obsAA.getCode().addCoding().setSystem(URL_MY_CODE_SYSTEM).setCode("AA");
IIdType idAA = myObservationDao.create(obsAA, mySrd).getId().toUnqualifiedVersionless();
@@ -519,32 +533,106 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
SearchParameterMap params = new SearchParameterMap();
params.add(Observation.SP_CODE, new TokenParam(URL_MY_CODE_SYSTEM, "A").setModifier(TokenParamModifier.BELOW));
assertThat(toUnqualifiedVersionlessIdValues(myObservationDao.search(params)), containsInAnyOrder(idAA.getValue()));
-
+
params = new SearchParameterMap();
params.add(Observation.SP_CODE, new TokenParam(URL_MY_CODE_SYSTEM, "AAA").setModifier(TokenParamModifier.BELOW));
assertThat(toUnqualifiedVersionlessIdValues(myObservationDao.search(params)), empty());
}
+ @Test
+ public void testSearchCodeInBuiltInValueSet() {
+ AllergyIntolerance ai1 = new AllergyIntolerance();
+ ai1.setStatus(AllergyIntoleranceStatus.ACTIVE);
+ String id1 = myAllergyIntoleranceDao.create(ai1, mySrd).getId().toUnqualifiedVersionless().getValue();
+
+ AllergyIntolerance ai2 = new AllergyIntolerance();
+ ai2.setStatus(AllergyIntoleranceStatus.CONFIRMED);
+ String id2 = myAllergyIntoleranceDao.create(ai2, mySrd).getId().toUnqualifiedVersionless().getValue();
+
+ AllergyIntolerance ai3 = new AllergyIntolerance();
+ ai3.setStatus(AllergyIntoleranceStatus.INACTIVE);
+ String id3 = myAllergyIntoleranceDao.create(ai3, mySrd).getId().toUnqualifiedVersionless().getValue();
+
+ SearchParameterMap params;
+ params = new SearchParameterMap();
+ params.add(AllergyIntolerance.SP_STATUS, new TokenParam(null, "http://hl7.org/fhir/ValueSet/allergy-intolerance-status").setModifier(TokenParamModifier.IN));
+ assertThat(toUnqualifiedVersionlessIdValues(myAllergyIntoleranceDao.search(params)), containsInAnyOrder(id1, id2, id3));
+
+ // No codes in this one
+ params = new SearchParameterMap();
+ params.add(AllergyIntolerance.SP_STATUS, new TokenParam(null, "http://hl7.org/fhir/ValueSet/allergy-intolerance-criticality").setModifier(TokenParamModifier.IN));
+ assertThat(toUnqualifiedVersionlessIdValues(myAllergyIntoleranceDao.search(params)), empty());
+
+ // Invalid VS
+ params = new SearchParameterMap();
+ params.add(AllergyIntolerance.SP_STATUS, new TokenParam(null, "http://hl7.org/fhir/ValueSet/FOO").setModifier(TokenParamModifier.IN));
+ try {
+ myAllergyIntoleranceDao.search(params);
+ } catch (InvalidRequestException e) {
+ assertEquals("Unable to find imported value set http://hl7.org/fhir/ValueSet/FOO", e.getMessage());
+ }
+
+ }
+
+ /**
+ * Todo: not yet implemented
+ */
+ @Test
+ @Ignore
+ public void testSearchCodeNotInBuiltInValueSet() {
+ AllergyIntolerance ai1 = new AllergyIntolerance();
+ ai1.setStatus(AllergyIntoleranceStatus.ACTIVE);
+ String id1 = myAllergyIntoleranceDao.create(ai1, mySrd).getId().toUnqualifiedVersionless().getValue();
+
+ AllergyIntolerance ai2 = new AllergyIntolerance();
+ ai2.setStatus(AllergyIntoleranceStatus.CONFIRMED);
+ String id2 = myAllergyIntoleranceDao.create(ai2, mySrd).getId().toUnqualifiedVersionless().getValue();
+
+ AllergyIntolerance ai3 = new AllergyIntolerance();
+ ai3.setStatus(AllergyIntoleranceStatus.INACTIVE);
+ String id3 = myAllergyIntoleranceDao.create(ai3, mySrd).getId().toUnqualifiedVersionless().getValue();
+
+ SearchParameterMap params;
+ params = new SearchParameterMap();
+ params.add(AllergyIntolerance.SP_STATUS, new TokenParam(null, "http://hl7.org/fhir/ValueSet/allergy-intolerance-status").setModifier(TokenParamModifier.NOT_IN));
+ assertThat(toUnqualifiedVersionlessIdValues(myAllergyIntoleranceDao.search(params)), empty());
+
+ // No codes in this one
+ params = new SearchParameterMap();
+ params.add(AllergyIntolerance.SP_STATUS, new TokenParam(null, "http://hl7.org/fhir/ValueSet/allergy-intolerance-criticality").setModifier(TokenParamModifier.NOT_IN));
+ assertThat(toUnqualifiedVersionlessIdValues(myAllergyIntoleranceDao.search(params)), containsInAnyOrder(id1, id2, id3));
+
+ // Invalid VS
+ params = new SearchParameterMap();
+ params.add(AllergyIntolerance.SP_STATUS, new TokenParam(null, "http://hl7.org/fhir/ValueSet/FOO").setModifier(TokenParamModifier.NOT_IN));
+ try {
+ myAllergyIntoleranceDao.search(params);
+ } catch (InvalidRequestException e) {
+ assertEquals("Unable to find imported value set http://hl7.org/fhir/ValueSet/FOO", e.getMessage());
+ }
+
+ }
+
@Test
public void testSearchCodeBelowBuiltInCodesystem() {
AllergyIntolerance ai1 = new AllergyIntolerance();
ai1.setStatus(AllergyIntoleranceStatus.ACTIVE);
String id1 = myAllergyIntoleranceDao.create(ai1, mySrd).getId().toUnqualifiedVersionless().getValue();
-
+
AllergyIntolerance ai2 = new AllergyIntolerance();
ai2.setStatus(AllergyIntoleranceStatus.CONFIRMED);
String id2 = myAllergyIntoleranceDao.create(ai2, mySrd).getId().toUnqualifiedVersionless().getValue();
-
+
AllergyIntolerance ai3 = new AllergyIntolerance();
ai3.setStatus(AllergyIntoleranceStatus.INACTIVE);
String id3 = myAllergyIntoleranceDao.create(ai3, mySrd).getId().toUnqualifiedVersionless().getValue();
-
+
SearchParameterMap params;
params = new SearchParameterMap();
params.add(AllergyIntolerance.SP_STATUS, new TokenParam("http://hl7.org/fhir/allergy-intolerance-status", AllergyIntoleranceStatus.ACTIVE.toCode()));
assertThat(toUnqualifiedVersionlessIdValues(myAllergyIntoleranceDao.search(params)), containsInAnyOrder(id1));
-
+
params = new SearchParameterMap();
params.add(AllergyIntolerance.SP_STATUS, new TokenParam("http://hl7.org/fhir/allergy-intolerance-status", AllergyIntoleranceStatus.ACTIVE.toCode()).setModifier(TokenParamModifier.BELOW));
assertThat(toUnqualifiedVersionlessIdValues(myAllergyIntoleranceDao.search(params)), containsInAnyOrder(id1, id2));
@@ -574,25 +662,24 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
}
@Test
- @Ignore
public void testSearchCodeBelowBuiltInCodesystemUnqualified() {
AllergyIntolerance ai1 = new AllergyIntolerance();
ai1.setStatus(AllergyIntoleranceStatus.ACTIVE);
String id1 = myAllergyIntoleranceDao.create(ai1, mySrd).getId().toUnqualifiedVersionless().getValue();
-
+
AllergyIntolerance ai2 = new AllergyIntolerance();
ai2.setStatus(AllergyIntoleranceStatus.CONFIRMED);
String id2 = myAllergyIntoleranceDao.create(ai2, mySrd).getId().toUnqualifiedVersionless().getValue();
-
+
AllergyIntolerance ai3 = new AllergyIntolerance();
ai3.setStatus(AllergyIntoleranceStatus.INACTIVE);
String id3 = myAllergyIntoleranceDao.create(ai3, mySrd).getId().toUnqualifiedVersionless().getValue();
-
+
SearchParameterMap params;
params = new SearchParameterMap();
params.add(AllergyIntolerance.SP_STATUS, new TokenParam(null, AllergyIntoleranceStatus.ACTIVE.toCode()));
assertThat(toUnqualifiedVersionlessIdValues(myAllergyIntoleranceDao.search(params)), containsInAnyOrder(id1));
-
+
params = new SearchParameterMap();
params.add(AllergyIntolerance.SP_STATUS, new TokenParam(null, AllergyIntoleranceStatus.ACTIVE.toCode()).setModifier(TokenParamModifier.BELOW));
assertThat(toUnqualifiedVersionlessIdValues(myAllergyIntoleranceDao.search(params)), containsInAnyOrder(id1, id2));
@@ -611,13 +698,12 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
}
-
@Test
public void testSearchCodeInEmptyValueSet() {
ValueSet valueSet = new ValueSet();
valueSet.setUrl(URL_MY_VALUE_SET);
myValueSetDao.create(valueSet, mySrd);
-
+
Observation obsAA = new Observation();
obsAA.setStatus(ObservationStatus.FINAL);
obsAA.getCode().addCoding().setSystem(URL_MY_CODE_SYSTEM).setCode("AA");
@@ -634,11 +720,11 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
myObservationDao.create(obsCA, mySrd).getId().toUnqualifiedVersionless();
SearchParameterMap params;
-
+
params = new SearchParameterMap();
params.add(Observation.SP_CODE, new TokenParam(null, URL_MY_VALUE_SET).setModifier(TokenParamModifier.IN));
assertThat(toUnqualifiedVersionlessIdValues(myObservationDao.search(params)), empty());
-
+
params = new SearchParameterMap();
params.add(Observation.SP_CODE, new TokenParam(null, URL_MY_VALUE_SET).setModifier(TokenParamModifier.IN));
params.add(Observation.SP_STATUS, new TokenParam(null, "final"));
@@ -648,7 +734,7 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
@Test
public void testSearchCodeInExternalCodesystem() {
createExternalCsAndLocalVs();
-
+
Observation obsPA = new Observation();
obsPA.getCode().addCoding().setSystem(URL_MY_CODE_SYSTEM).setCode("ParentA");
IIdType idPA = myObservationDao.create(obsPA, mySrd).getId().toUnqualifiedVersionless();
@@ -665,7 +751,7 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
obsCA.getCode().addCoding().setSystem(URL_MY_CODE_SYSTEM).setCode("CA");
IIdType idCA = myObservationDao.create(obsCA, mySrd).getId().toUnqualifiedVersionless();
- SearchParameterMap params = new SearchParameterMap();
+ SearchParameterMap params = new SearchParameterMap();
params.add(Observation.SP_CODE, new TokenParam(URL_MY_CODE_SYSTEM, "childAA").setModifier(TokenParamModifier.BELOW));
assertThat(toUnqualifiedVersionlessIdValues(myObservationDao.search(params)), containsInAnyOrder(idAAA.getValue(), idAAB.getValue()));
@@ -676,17 +762,17 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
params = new SearchParameterMap();
params.add(Observation.SP_CODE, new TokenParam(null, URL_MY_VALUE_SET).setModifier(TokenParamModifier.IN));
assertThat(toUnqualifiedVersionlessIdValues(myObservationDao.search(params)), containsInAnyOrder(idPA.getValue(), idAAA.getValue(), idAAB.getValue()));
-
+
}
-
+
@Test
public void testSearchCodeInFhirCodesystem() {
createLocalCsAndVs();
-
+
AuditEvent aeIn1 = new AuditEvent();
aeIn1.getType().setSystem("http://nema.org/dicom/dicm").setCode("110102");
IIdType idIn1 = myAuditEventDao.create(aeIn1, mySrd).getId().toUnqualifiedVersionless();
-
+
AuditEvent aeIn2 = new AuditEvent();
aeIn2.getType().setSystem("http://hl7.org/fhir/audit-event-type").setCode("rest");
IIdType idIn2 = myAuditEventDao.create(aeIn2, mySrd).getId().toUnqualifiedVersionless();
@@ -697,17 +783,17 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
SearchParameterMap params = new SearchParameterMap();
params.add(AuditEvent.SP_TYPE, new TokenParam(null, "http://hl7.org/fhir/ValueSet/audit-event-type").setModifier(TokenParamModifier.IN));
- assertThat(toUnqualifiedVersionlessIdValues(myAuditEventDao.search(params)), containsInAnyOrder(idIn1.getValue(), idIn2.getValue()));
+ assertThat(toUnqualifiedVersionlessIdValues(myAuditEventDao.search(params)), containsInAnyOrder(idIn1.getValue(), idIn2.getValue()));
params = new SearchParameterMap();
params.add(AuditEvent.SP_TYPE, new TokenParam(null, "http://hl7.org/fhir/ValueSet/v3-PurposeOfUse").setModifier(TokenParamModifier.IN));
- assertThat(toUnqualifiedVersionlessIdValues(myAuditEventDao.search(params)), empty());
+ assertThat(toUnqualifiedVersionlessIdValues(myAuditEventDao.search(params)), empty());
}
@Test
public void testSearchCodeInLocalCodesystem() {
createLocalCsAndVs();
-
+
Observation obsAA = new Observation();
obsAA.getCode().addCoding().setSystem(URL_MY_CODE_SYSTEM).setCode("AA");
IIdType idAA = myObservationDao.create(obsAA, mySrd).getId().toUnqualifiedVersionless();
@@ -723,9 +809,8 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
SearchParameterMap params = new SearchParameterMap();
params.add(Observation.SP_CODE, new TokenParam(null, URL_MY_VALUE_SET).setModifier(TokenParamModifier.IN));
assertThat(toUnqualifiedVersionlessIdValues(myObservationDao.search(params)), containsInAnyOrder(idAA.getValue(), idBA.getValue()));
-
- }
+ }
private ArrayList toCodesContains(List theContains) {
ArrayList retVal = new ArrayList();
@@ -735,13 +820,9 @@ public class FhirResourceDaoDstu3TerminologyTest extends BaseJpaDstu3Test {
return retVal;
}
-
@AfterClass
public static void afterClassClearContext() {
TestUtil.clearAllStaticFieldsForUnitTest();
}
-
-
-
}
diff --git a/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3Test.java b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3Test.java
index 5f603e423e3..da319fa831a 100644
--- a/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3Test.java
+++ b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/dao/dstu3/FhirResourceDaoDstu3Test.java
@@ -3087,23 +3087,23 @@ public class FhirResourceDaoDstu3Test extends BaseJpaDstu3Test {
public void testSortByUri() {
ConceptMap res = new ConceptMap();
- res.addElement().addTarget().addDependsOn().setElement("http://foo2");
+ res.addGroup().setSource("http://foo2");
IIdType id2 = myConceptMapDao.create(res, mySrd).getId().toUnqualifiedVersionless();
res = new ConceptMap();
- res.addElement().addTarget().addDependsOn().setElement("http://foo1");
+ res.addGroup().setSource("http://foo1");
IIdType id1 = myConceptMapDao.create(res, mySrd).getId().toUnqualifiedVersionless();
res = new ConceptMap();
- res.addElement().addTarget().addDependsOn().setElement("http://bar3");
+ res.addGroup().setSource("http://bar3");
IIdType id3 = myConceptMapDao.create(res, mySrd).getId().toUnqualifiedVersionless();
res = new ConceptMap();
- res.addElement().addTarget().addDependsOn().setElement("http://bar4");
+ res.addGroup().setSource("http://bar4");
IIdType id4 = myConceptMapDao.create(res, mySrd).getId().toUnqualifiedVersionless();
SearchParameterMap pm = new SearchParameterMap();
- pm.setSort(new SortSpec(ConceptMap.SP_DEPENDSON));
+ pm.setSort(new SortSpec(ConceptMap.SP_SOURCE));
List actual = toUnqualifiedVersionlessIds(myConceptMapDao.search(pm));
assertEquals(4, actual.size());
assertThat(actual, contains(id1, id2, id3, id4));
diff --git a/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/provider/dstu3/AuthorizationInterceptorResourceProviderDstu3Test.java b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/provider/dstu3/AuthorizationInterceptorResourceProviderDstu3Test.java
index 2a565cade14..d46179cf600 100644
--- a/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/provider/dstu3/AuthorizationInterceptorResourceProviderDstu3Test.java
+++ b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/provider/dstu3/AuthorizationInterceptorResourceProviderDstu3Test.java
@@ -1,124 +1,35 @@
package ca.uhn.fhir.jpa.provider.dstu3;
-import static org.hamcrest.Matchers.contains;
-import static org.hamcrest.Matchers.containsInAnyOrder;
-import static org.hamcrest.Matchers.containsInRelativeOrder;
-import static org.hamcrest.Matchers.containsString;
-import static org.hamcrest.Matchers.empty;
-import static org.hamcrest.Matchers.greaterThan;
-import static org.hamcrest.Matchers.hasItems;
-import static org.hamcrest.Matchers.not;
import static org.hamcrest.Matchers.startsWith;
-import static org.hamcrest.Matchers.stringContainsInOrder;
import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertNotEquals;
-import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertThat;
-import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
-import java.io.BufferedReader;
import java.io.IOException;
-import java.io.InputStreamReader;
-import java.net.InetSocketAddress;
-import java.net.Socket;
-import java.net.SocketTimeoutException;
import java.util.ArrayList;
-import java.util.Date;
import java.util.List;
-import org.apache.commons.io.IOUtils;
-import org.apache.commons.lang3.StringUtils;
-import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpDelete;
-import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
-import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
-import org.hl7.fhir.dstu3.model.BaseResource;
-import org.hl7.fhir.dstu3.model.Bundle;
-import org.hl7.fhir.dstu3.model.Bundle.BundleEntryComponent;
-import org.hl7.fhir.dstu3.model.Bundle.BundleType;
-import org.hl7.fhir.dstu3.model.Bundle.HTTPVerb;
-import org.hl7.fhir.dstu3.model.Bundle.SearchEntryMode;
-import org.hl7.fhir.dstu3.model.CodeSystem;
-import org.hl7.fhir.dstu3.model.Coding;
-import org.hl7.fhir.dstu3.model.Condition;
-import org.hl7.fhir.dstu3.model.DateTimeType;
-import org.hl7.fhir.dstu3.model.DateType;
-import org.hl7.fhir.dstu3.model.Device;
-import org.hl7.fhir.dstu3.model.DiagnosticOrder;
-import org.hl7.fhir.dstu3.model.DocumentManifest;
-import org.hl7.fhir.dstu3.model.DocumentReference;
-import org.hl7.fhir.dstu3.model.Encounter;
-import org.hl7.fhir.dstu3.model.Encounter.EncounterClass;
-import org.hl7.fhir.dstu3.model.Encounter.EncounterLocationComponent;
-import org.hl7.fhir.dstu3.model.Encounter.EncounterState;
-import org.hl7.fhir.dstu3.model.Enumerations.AdministrativeGender;
import org.hl7.fhir.dstu3.model.IdType;
-import org.hl7.fhir.dstu3.model.ImagingStudy;
-import org.hl7.fhir.dstu3.model.InstantType;
-import org.hl7.fhir.dstu3.model.Location;
-import org.hl7.fhir.dstu3.model.Medication;
-import org.hl7.fhir.dstu3.model.MedicationOrder;
-import org.hl7.fhir.dstu3.model.Meta;
-import org.hl7.fhir.dstu3.model.Narrative.NarrativeStatus;
-import org.hl7.fhir.dstu3.model.Observation;
-import org.hl7.fhir.dstu3.model.OperationOutcome;
-import org.hl7.fhir.dstu3.model.Organization;
-import org.hl7.fhir.dstu3.model.Parameters;
import org.hl7.fhir.dstu3.model.Patient;
-import org.hl7.fhir.dstu3.model.Period;
-import org.hl7.fhir.dstu3.model.Practitioner;
-import org.hl7.fhir.dstu3.model.Questionnaire;
-import org.hl7.fhir.dstu3.model.Questionnaire.QuestionnaireItemType;
-import org.hl7.fhir.dstu3.model.QuestionnaireResponse;
-import org.hl7.fhir.dstu3.model.Reference;
-import org.hl7.fhir.dstu3.model.StringType;
-import org.hl7.fhir.dstu3.model.Subscription;
-import org.hl7.fhir.dstu3.model.Subscription.SubscriptionChannelType;
-import org.hl7.fhir.dstu3.model.Subscription.SubscriptionStatus;
-import org.hl7.fhir.dstu3.model.TemporalPrecisionEnum;
-import org.hl7.fhir.dstu3.model.UnsignedIntType;
-import org.hl7.fhir.dstu3.model.ValueSet;
-import org.hl7.fhir.instance.model.api.IBaseResource;
-import org.hl7.fhir.instance.model.api.IIdType;
import org.junit.AfterClass;
-import org.junit.Ignore;
import org.junit.Test;
-import ca.uhn.fhir.jpa.dao.SearchParameterMap;
import ca.uhn.fhir.model.primitive.IdDt;
-import ca.uhn.fhir.model.primitive.UriDt;
import ca.uhn.fhir.rest.api.MethodOutcome;
-import ca.uhn.fhir.rest.api.SummaryEnum;
-import ca.uhn.fhir.rest.client.IGenericClient;
import ca.uhn.fhir.rest.method.RequestDetails;
-import ca.uhn.fhir.rest.param.DateRangeParam;
-import ca.uhn.fhir.rest.param.ParamPrefixEnum;
-import ca.uhn.fhir.rest.param.StringAndListParam;
-import ca.uhn.fhir.rest.param.StringOrListParam;
-import ca.uhn.fhir.rest.param.StringParam;
-import ca.uhn.fhir.rest.param.TokenParam;
import ca.uhn.fhir.rest.server.Constants;
-import ca.uhn.fhir.rest.server.IBundleProvider;
-import ca.uhn.fhir.rest.server.exceptions.AuthenticationException;
import ca.uhn.fhir.rest.server.exceptions.ForbiddenOperationException;
-import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException;
-import ca.uhn.fhir.rest.server.exceptions.PreconditionFailedException;
-import ca.uhn.fhir.rest.server.exceptions.ResourceGoneException;
-import ca.uhn.fhir.rest.server.exceptions.UnprocessableEntityException;
import ca.uhn.fhir.rest.server.interceptor.IServerInterceptor;
import ca.uhn.fhir.rest.server.interceptor.auth.AuthorizationInterceptor;
import ca.uhn.fhir.rest.server.interceptor.auth.IAuthRule;
import ca.uhn.fhir.rest.server.interceptor.auth.PolicyEnum;
import ca.uhn.fhir.rest.server.interceptor.auth.RuleBuilder;
-import ca.uhn.fhir.rest.server.servlet.ServletRequestDetails;
import ca.uhn.fhir.util.TestUtil;
-import ca.uhn.fhir.util.UrlUtil;
public class AuthorizationInterceptorResourceProviderDstu3Test extends BaseResourceProviderDstu3Test {
diff --git a/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/provider/dstu3/ResourceProviderDstu3Test.java b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/provider/dstu3/ResourceProviderDstu3Test.java
index 01d6dbfcb9b..e97f9424fd8 100644
--- a/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/provider/dstu3/ResourceProviderDstu3Test.java
+++ b/hapi-fhir-jpaserver-base/src/test/java/ca/uhn/fhir/jpa/provider/dstu3/ResourceProviderDstu3Test.java
@@ -41,7 +41,6 @@ import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
-import org.hamcrest.Matchers;
import org.hl7.fhir.dstu3.model.BaseResource;
import org.hl7.fhir.dstu3.model.Bundle;
import org.hl7.fhir.dstu3.model.Bundle.BundleEntryComponent;
@@ -59,7 +58,6 @@ import org.hl7.fhir.dstu3.model.DiagnosticOrder;
import org.hl7.fhir.dstu3.model.DocumentManifest;
import org.hl7.fhir.dstu3.model.DocumentReference;
import org.hl7.fhir.dstu3.model.Encounter;
-import org.hl7.fhir.dstu3.model.Encounter.EncounterClass;
import org.hl7.fhir.dstu3.model.Encounter.EncounterLocationComponent;
import org.hl7.fhir.dstu3.model.Encounter.EncounterState;
import org.hl7.fhir.dstu3.model.Enumerations.AdministrativeGender;
@@ -89,7 +87,6 @@ import org.hl7.fhir.dstu3.model.Subscription.SubscriptionStatus;
import org.hl7.fhir.dstu3.model.TemporalPrecisionEnum;
import org.hl7.fhir.dstu3.model.UnsignedIntType;
import org.hl7.fhir.dstu3.model.ValueSet;
-import org.hl7.fhir.instance.model.api.IBaseBundle;
import org.hl7.fhir.instance.model.api.IBaseResource;
import org.hl7.fhir.instance.model.api.IIdType;
import org.junit.AfterClass;
@@ -113,7 +110,6 @@ import ca.uhn.fhir.rest.server.exceptions.InvalidRequestException;
import ca.uhn.fhir.rest.server.exceptions.PreconditionFailedException;
import ca.uhn.fhir.rest.server.exceptions.ResourceGoneException;
import ca.uhn.fhir.rest.server.exceptions.UnprocessableEntityException;
-import ca.uhn.fhir.util.BundleUtil;
import ca.uhn.fhir.util.TestUtil;
import ca.uhn.fhir.util.UrlUtil;
@@ -652,7 +648,6 @@ public class ResourceProviderDstu3Test extends BaseResourceProviderDstu3Test {
Encounter e1 = new Encounter();
e1.addIdentifier().setSystem("urn:foo").setValue("testDeepChainingE1");
e1.getStatusElement().setValue(EncounterState.INPROGRESS);
- e1.getClass_Element().setValue(EncounterClass.HOME);
EncounterLocationComponent location = e1.addLocation();
location.getLocation().setReferenceElement(l2id.toUnqualifiedVersionless());
location.setPeriod(new Period().setStart(new Date(), TemporalPrecisionEnum.SECOND).setEnd(new Date(), TemporalPrecisionEnum.SECOND));
diff --git a/hapi-fhir-structures-dstu/src/main/java/ca/uhn/fhir/rest/server/audit/IResourceAuditor.java b/hapi-fhir-structures-dstu/src/main/java/ca/uhn/fhir/rest/server/audit/IResourceAuditor.java
index 40f275b68d3..e8f458c5af6 100644
--- a/hapi-fhir-structures-dstu/src/main/java/ca/uhn/fhir/rest/server/audit/IResourceAuditor.java
+++ b/hapi-fhir-structures-dstu/src/main/java/ca/uhn/fhir/rest/server/audit/IResourceAuditor.java
@@ -2,7 +2,7 @@ package ca.uhn.fhir.rest.server.audit;
/*
* #%L
- * HAPI FHIR - Core Library
+ * HAPI FHIR Structures - DSTU1 (FHIR v0.80)
* %%
* Copyright (C) 2014 - 2016 University Health Network
* %%
diff --git a/hapi-fhir-structures-dstu2/src/main/java/ca/uhn/fhir/rest/server/provider/dstu2/ServerConformanceProvider.java b/hapi-fhir-structures-dstu2/src/main/java/ca/uhn/fhir/rest/server/provider/dstu2/ServerConformanceProvider.java
index 17d1e2f4ee9..7d3061e3844 100644
--- a/hapi-fhir-structures-dstu2/src/main/java/ca/uhn/fhir/rest/server/provider/dstu2/ServerConformanceProvider.java
+++ b/hapi-fhir-structures-dstu2/src/main/java/ca/uhn/fhir/rest/server/provider/dstu2/ServerConformanceProvider.java
@@ -43,7 +43,6 @@ import org.hl7.fhir.instance.model.api.IBaseResource;
import ca.uhn.fhir.context.RuntimeResourceDefinition;
import ca.uhn.fhir.context.RuntimeSearchParam;
-import ca.uhn.fhir.model.api.IResource;
import ca.uhn.fhir.model.dstu2.resource.Conformance;
import ca.uhn.fhir.model.dstu2.resource.Conformance.Rest;
import ca.uhn.fhir.model.dstu2.resource.Conformance.RestResource;
diff --git a/hapi-fhir-structures-dstu2/src/test/java/ca/uhn/fhir/model/dstu2/ModelDstu2Test.java b/hapi-fhir-structures-dstu2/src/test/java/ca/uhn/fhir/model/dstu2/ModelDstu2Test.java
index cd9b71d66a4..df2d08deb14 100644
--- a/hapi-fhir-structures-dstu2/src/test/java/ca/uhn/fhir/model/dstu2/ModelDstu2Test.java
+++ b/hapi-fhir-structures-dstu2/src/test/java/ca/uhn/fhir/model/dstu2/ModelDstu2Test.java
@@ -9,15 +9,19 @@ import java.util.List;
import org.junit.AfterClass;
import org.junit.Test;
+import ca.uhn.fhir.context.BaseRuntimeDeclaredChildDefinition;
import ca.uhn.fhir.context.FhirContext;
+import ca.uhn.fhir.context.RuntimeResourceDefinition;
import ca.uhn.fhir.model.dstu2.composite.CodeableConceptDt;
import ca.uhn.fhir.model.dstu2.composite.CodingDt;
import ca.uhn.fhir.model.dstu2.composite.IdentifierDt;
import ca.uhn.fhir.model.dstu2.composite.MetaDt;
+import ca.uhn.fhir.model.dstu2.resource.Appointment;
import ca.uhn.fhir.model.dstu2.resource.Claim;
import ca.uhn.fhir.model.dstu2.resource.Patient;
import ca.uhn.fhir.model.dstu2.resource.Practitioner;
import ca.uhn.fhir.model.dstu2.resource.Practitioner.PractitionerRole;
+import ca.uhn.fhir.util.FhirTerser;
import ca.uhn.fhir.util.TestUtil;
public class ModelDstu2Test {
@@ -28,7 +32,17 @@ public class ModelDstu2Test {
public void testCompositeNames() {
assertEquals(MetaDt.class, ourCtx.getElementDefinition("meta").getImplementingClass());
}
-
+
+ @Test
+ public void testModelBindings() {
+ FhirTerser t = ourCtx.newTerser();
+ RuntimeResourceDefinition def = ourCtx.getResourceDefinition(Patient.class);
+ assertEquals("http://hl7.org/fhir/ValueSet/administrative-gender", ((BaseRuntimeDeclaredChildDefinition)def.getChildByName("gender")).getBindingValueSet());
+ assertEquals("http://hl7.org/fhir/ValueSet/link-type", ((BaseRuntimeDeclaredChildDefinition)t.getDefinition(Patient.class, "Patient.link.type")).getBindingValueSet());
+
+ def = ourCtx.getResourceDefinition(Appointment.class);
+ assertEquals("http://hl7.org/fhir/ValueSet/appointmentstatus", ((BaseRuntimeDeclaredChildDefinition)def.getChildByName("status")).getBindingValueSet());
+ }
/**
* See #320
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/Element.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/Element.java
similarity index 84%
rename from hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/Element.java
rename to hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/Element.java
index 8b119548f25..015242bdf53 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/Element.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/Element.java
@@ -1,4 +1,4 @@
-package org.hl7.fhir.dstu3.metamodel;
+package org.hl7.fhir.dstu3.elementmodel;
import static org.apache.commons.lang3.StringUtils.isNotBlank;
@@ -6,8 +6,8 @@ import java.util.ArrayList;
import java.util.List;
import org.apache.commons.lang3.Validate;
+import org.hl7.fhir.dstu3.elementmodel.Element.SpecialElement;
import org.hl7.fhir.dstu3.exceptions.FHIRException;
-import org.hl7.fhir.dstu3.metamodel.Element.SpecialElement;
import org.hl7.fhir.dstu3.model.Base;
import org.hl7.fhir.dstu3.model.ElementDefinition;
import org.hl7.fhir.dstu3.model.StructureDefinition;
@@ -28,7 +28,17 @@ import org.hl7.fhir.utilities.xhtml.XhtmlNode;
public class Element extends Base {
public enum SpecialElement {
- CONTAINED, BUNDLE_ENTRY;
+ CONTAINED, BUNDLE_ENTRY, PARAMETER;
+
+ public static SpecialElement fromProperty(Property property) {
+ if (property.getStructure().getId().equals("Parameters"))
+ return PARAMETER;
+ if (property.getStructure().getId().equals("Bundle"))
+ return BUNDLE_ENTRY;
+ if (property.getName().equals("contained"))
+ return CONTAINED;
+ throw new Error("Unknown resource containing a native resource: "+property.getDefinition().getId());
+ }
}
private List comments;// not relevant for production, but useful in documentation
@@ -38,10 +48,9 @@ public class Element extends Base {
private int index = -1;
private List children;
private Property property;
+ private Property elementProperty; // this is used when special is set to true - it tracks the underlying element property which is used in a few places
private int line;
private int col;
- private ElementDefinition validatorDefinition;
- private StructureDefinition validatorProfile;
private SpecialElement special;
private XhtmlNode xhtml; // if this is populated, then value will also hold the string representation
@@ -64,8 +73,9 @@ public class Element extends Base {
this.value = value;
}
- public void updateProperty(Property property, SpecialElement special) {
+ public void updateProperty(Property property, SpecialElement special, Property elementProperty) {
this.property = property;
+ this.elementProperty = elementProperty;
this.special = special;
}
@@ -244,7 +254,7 @@ public class Element extends Base {
if (isPrimitive())
return value;
else {
- if (hasPrimitiveValue()) {
+ if (hasPrimitiveValue() && children != null) {
for (Element c : children) {
if (c.getName().equals("value"))
return c.primitiveValue();
@@ -270,8 +280,6 @@ public class Element extends Base {
}
public void markValidation(StructureDefinition profile, ElementDefinition definition) {
- validatorProfile = profile;
- validatorDefinition = definition;
}
public Element getNamedChild(String name) {
@@ -337,5 +345,13 @@ public class Element extends Base {
return true;
}
+ public Property getElementProperty() {
+ return elementProperty;
+ }
+
+ public boolean hasElementProperty() {
+ return elementProperty != null;
+ }
+
}
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/JsonLDParser.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/JsonLDParser.java
new file mode 100644
index 00000000000..1ce1716090b
--- /dev/null
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/JsonLDParser.java
@@ -0,0 +1,205 @@
+package org.hl7.fhir.dstu3.elementmodel;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.OutputStreamWriter;
+import java.math.BigDecimal;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+import org.apache.commons.lang3.NotImplementedException;
+import org.hl7.fhir.dstu3.formats.IParser.OutputStyle;
+import org.hl7.fhir.dstu3.formats.JsonCreator;
+import org.hl7.fhir.dstu3.formats.JsonCreatorCanonical;
+import org.hl7.fhir.dstu3.formats.JsonCreatorGson;
+import org.hl7.fhir.dstu3.utils.IWorkerContext;
+import org.hl7.fhir.utilities.Utilities;
+
+public class JsonLDParser extends ParserBase {
+
+ private JsonCreator json;
+ private String base;
+
+ public JsonLDParser(IWorkerContext context) {
+ super(context);
+ }
+
+ @Override
+ public Element parse(InputStream stream) throws Exception {
+ throw new NotImplementedException("not done yet");
+ }
+
+
+ protected void prop(String name, String value) throws IOException {
+ if (name != null)
+ json.name(name);
+ json.value(value);
+ }
+
+ protected void open(String name) throws IOException {
+ if (name != null)
+ json.name(name);
+ json.beginObject();
+ }
+
+ protected void close() throws IOException {
+ json.endObject();
+ }
+
+ protected void openArray(String name) throws IOException {
+ if (name != null)
+ json.name(name);
+ json.beginArray();
+ }
+
+ protected void closeArray() throws IOException {
+ json.endArray();
+ }
+
+
+ @Override
+ public void compose(Element e, OutputStream stream, OutputStyle style, String base) throws Exception {
+ this.base = base;
+ OutputStreamWriter osw = new OutputStreamWriter(stream, "UTF-8");
+ if (style == OutputStyle.CANONICAL)
+ json = new JsonCreatorCanonical(osw);
+ else
+ json = new JsonCreatorGson(osw);
+ json.setIndent(style == OutputStyle.PRETTY ? " " : "");
+ json.beginObject();
+ prop("@context", "http://hl7.org/fhir/jsonld/"+e.getType());
+ prop("resourceType", e.getType());
+ Set done = new HashSet();
+ for (Element child : e.getChildren()) {
+ compose(e.getName(), e, done, child);
+ }
+ json.endObject();
+ json.finish();
+ osw.flush();
+ }
+
+ private void compose(String path, Element e, Set done, Element child) throws IOException {
+ if (!child.getProperty().isList()) {
+ compose(path, child);
+ } else if (!done.contains(child.getName())) {
+ done.add(child.getName());
+ List list = e.getChildrenByName(child.getName());
+ composeList(path, list);
+ }
+ }
+
+ private void composeList(String path, List list) throws IOException {
+ // there will be at least one element
+ String en = list.get(0).getProperty().getDefinition().getBase().getPath();
+ if (en == null)
+ en = list.get(0).getProperty().getDefinition().getPath();
+ boolean doType = false;
+ if (en.endsWith("[x]")) {
+ en = en.substring(0, en.length()-3);
+ doType = true;
+ }
+ if (doType)
+ en = en + Utilities.capitalize(list.get(0).getType());
+
+ openArray(en);
+ for (Element item : list) {
+ open(null);
+ if (item.isPrimitive() || isPrimitive(item.getType())) {
+ if (item.hasValue())
+ primitiveValue(item);
+ }
+ Set done = new HashSet();
+ for (Element child : item.getChildren()) {
+ compose(path+"."+item.getName(), item, done, child);
+ }
+ close();
+ }
+ closeArray();
+ }
+
+ private void primitiveValue(Element item) throws IOException {
+ json.name("value");
+ String type = item.getType();
+ if (Utilities.existsInList(type, "boolean"))
+ json.value(item.getValue().equals("true") ? new Boolean(true) : new Boolean(false));
+ else if (Utilities.existsInList(type, "integer", "unsignedInt", "positiveInt"))
+ json.value(new Integer(item.getValue()));
+ else if (Utilities.existsInList(type, "decimal"))
+ json.value(new BigDecimal(item.getValue()));
+ else
+ json.value(item.getValue());
+ }
+
+ private void compose(String path, Element element) throws IOException {
+ String en = element.getProperty().getDefinition().getBase().getPath();
+ if (en == null)
+ en = element.getProperty().getDefinition().getPath();
+ boolean doType = false;
+ if (en.endsWith("[x]")) {
+ en = en.substring(0, en.length()-3);
+ doType = true;
+ }
+ if (doType)
+ en = en + Utilities.capitalize(element.getType());
+
+ if (element.hasChildren() || element.hasComments() || element.hasValue()) {
+ open(en);
+
+ if (element.isPrimitive() || isPrimitive(element.getType())) {
+ if (element.hasValue())
+ primitiveValue(element);
+ }
+ if (element.getProperty().isResource()) {
+ prop("resourceType", element.getType());
+ element = element.getChildren().get(0);
+ }
+ Set done = new HashSet();
+ for (Element child : element.getChildren()) {
+ compose(path+"."+element.getName(), element, done, child);
+ }
+ if ("Coding".equals(element.getType()))
+ decorateCoding(element);
+ if ("CodeableConcept".equals(element.getType()))
+ decorateCodeableConcept(element);
+ if ("Reference".equals(element.getType()))
+ decorateReference(element);
+
+ close();
+ }
+ }
+
+ private void decorateReference(Element element) throws IOException {
+ String ref = element.getChildValue("reference");
+ if (ref != null && (ref.startsWith("http://") || ref.startsWith("https://"))) {
+ json.name("reference");
+ json.value(ref);
+ } else if (base != null && ref != null && ref.contains("/")) {
+ json.name("reference");
+ json.value(base+"/"+ref);
+ }
+ }
+
+ protected void decorateCoding(Element coding) throws IOException {
+ String system = coding.getChildValue("system");
+ String code = coding.getChildValue("code");
+
+ if (system == null)
+ return;
+ if ("http://snomed.info/sct".equals(system)) {
+ json.name("concept");
+ json.value("http://snomed.info/sct#"+code);
+ } else if ("http://loinc.org".equals(system)) {
+ json.name("concept");
+ json.value("http://loinc.org/owl#"+code);
+ }
+ }
+
+ private void decorateCodeableConcept(Element element) throws IOException {
+ for (Element c : element.getChildren("coding")) {
+ decorateCoding(c);
+ }
+ }
+
+}
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/JsonParser.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/JsonParser.java
similarity index 94%
rename from hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/JsonParser.java
rename to hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/JsonParser.java
index 3adb302136e..000968d7169 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/JsonParser.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/JsonParser.java
@@ -1,4 +1,4 @@
-package org.hl7.fhir.dstu3.metamodel;
+package org.hl7.fhir.dstu3.elementmodel;
import java.io.IOException;
import java.io.InputStream;
@@ -14,12 +14,12 @@ import java.util.Set;
import org.apache.commons.lang3.NotImplementedException;
import org.hl7.fhir.dstu3.formats.IParser.OutputStyle;
-import org.hl7.fhir.dstu3.metamodel.Element.SpecialElement;
-import org.hl7.fhir.dstu3.metamodel.ParserBase.ValidationPolicy;
import org.hl7.fhir.dstu3.model.StructureDefinition;
import org.hl7.fhir.dstu3.model.ElementDefinition.TypeRefComponent;
import org.hl7.fhir.dstu3.model.OperationOutcome.IssueSeverity;
import org.hl7.fhir.dstu3.model.OperationOutcome.IssueType;
+import org.hl7.fhir.dstu3.elementmodel.Element.SpecialElement;
+import org.hl7.fhir.dstu3.elementmodel.ParserBase.ValidationPolicy;
import org.hl7.fhir.dstu3.exceptions.DefinitionException;
import org.hl7.fhir.dstu3.exceptions.FHIRFormatError;
import org.hl7.fhir.dstu3.formats.FormatUtilities;
@@ -176,7 +176,7 @@ public class JsonParser extends ParserBase {
checkObject(child, npath);
context.getChildren().add(n);
if (property.isResource())
- parseResource(npath, child, n);
+ parseResource(npath, child, n, property);
else
parseChildren(npath, child, n, false);
} else
@@ -251,7 +251,7 @@ public class JsonParser extends ParserBase {
}
- private void parseResource(String npath, JsonObject res, Element parent) throws DefinitionException, FHIRFormatError {
+ private void parseResource(String npath, JsonObject res, Element parent, Property elementProperty) throws DefinitionException, FHIRFormatError {
JsonElement rt = res.get("resourceType");
if (rt == null) {
logError(line(res), col(res), npath, IssueType.INVALID, "Unable to find resourceType property", IssueSeverity.FATAL);
@@ -260,7 +260,7 @@ public class JsonParser extends ParserBase {
StructureDefinition sd = context.fetchResource(StructureDefinition.class, "http://hl7.org/fhir/StructureDefinition/"+name);
if (sd == null)
throw new FHIRFormatError("Contained resource does not appear to be a FHIR resource (unknown name '"+name+"')");
- parent.updateProperty(new Property(context, sd.getSnapshot().getElement().get(0), sd), parent.getProperty().getName().equals("contained") ? SpecialElement.CONTAINED : SpecialElement.BUNDLE_ENTRY);
+ parent.updateProperty(new Property(context, sd.getSnapshot().getElement().get(0), sd), SpecialElement.fromProperty(parent.getProperty()), elementProperty);
parent.setType(name);
parseChildren(npath, res, parent, true);
}
@@ -353,7 +353,8 @@ public class JsonParser extends ParserBase {
}
private void compose(String path, Element e, Set done, Element child) throws IOException {
- if (child.getSpecial() == SpecialElement.BUNDLE_ENTRY || !child.getProperty().isList()) {// for specials, ignore the cardinality of the stated type
+ boolean isList = child.hasElementProperty() ? child.getElementProperty().isList() : child.getProperty().isList();
+ if (!isList) {// for specials, ignore the cardinality of the stated type
compose(path, child);
} else if (!done.contains(child.getName())) {
done.add(child.getName());
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/Manager.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/Manager.java
similarity index 62%
rename from hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/Manager.java
rename to hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/Manager.java
index 1719d6acd99..57c1704f1cf 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/Manager.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/Manager.java
@@ -1,4 +1,4 @@
-package org.hl7.fhir.dstu3.metamodel;
+package org.hl7.fhir.dstu3.elementmodel;
import java.io.InputStream;
import java.io.OutputStream;
@@ -8,7 +8,22 @@ import org.hl7.fhir.dstu3.utils.IWorkerContext;
public class Manager {
- public enum FhirFormat { XML, JSON, JSONLD, TURTLE }
+ public enum FhirFormat { XML, JSON, JSONLD, TURTLE ;
+
+ public String getExtension() {
+ switch (this) {
+ case JSON:
+ return "json";
+ case JSONLD:
+ return "ld.json";
+ case TURTLE:
+ return "ttl";
+ case XML:
+ return "xml";
+ }
+ return null;
+ }
+ }
public static Element parse(IWorkerContext context, InputStream source, FhirFormat inputFormat) throws Exception {
return makeParser(context, inputFormat).parse(source);
@@ -21,7 +36,9 @@ public class Manager {
public static ParserBase makeParser(IWorkerContext context, FhirFormat format) {
switch (format) {
case JSON : return new JsonParser(context);
+ case JSONLD : return new JsonLDParser(context);
case XML : return new XmlParser(context);
+ case TURTLE : return new TurtleParser(context);
}
return null;
}
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/ObjectConverter.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/ObjectConverter.java
new file mode 100644
index 00000000000..68e8115c264
--- /dev/null
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/ObjectConverter.java
@@ -0,0 +1,71 @@
+package org.hl7.fhir.dstu3.elementmodel;
+
+import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
+import java.util.List;
+
+import org.hl7.fhir.dstu3.exceptions.FHIRException;
+import org.hl7.fhir.dstu3.model.Base;
+import org.hl7.fhir.dstu3.model.ElementDefinition;
+import org.hl7.fhir.dstu3.model.PrimitiveType;
+import org.hl7.fhir.dstu3.model.Resource;
+import org.hl7.fhir.dstu3.model.StructureDefinition;
+import org.hl7.fhir.dstu3.model.StructureDefinition.StructureDefinitionKind;
+import org.hl7.fhir.dstu3.model.Type;
+import org.hl7.fhir.dstu3.utils.IWorkerContext;
+import org.hl7.fhir.dstu3.utils.ProfileUtilities;
+
+public class ObjectConverter {
+
+ private IWorkerContext context;
+
+ public ObjectConverter(IWorkerContext context) {
+ this.context = context;
+ }
+
+ public Element convert(Resource ig) throws Exception {
+ ByteArrayOutputStream bs = new ByteArrayOutputStream();
+ org.hl7.fhir.dstu3.formats.JsonParser jp = new org.hl7.fhir.dstu3.formats.JsonParser();
+ jp.compose(bs, ig);
+ ByteArrayInputStream bi = new ByteArrayInputStream(bs.toByteArray());
+ return new JsonParser(context).parse(bi);
+ }
+
+ public Element convert(Property property, Type type) throws FHIRException {
+ return convertElement(property, type);
+ }
+
+ private Element convertElement(Property property, Base base) throws FHIRException {
+ if (base == null)
+ return null;
+ String tn = base.fhirType();
+ StructureDefinition sd = context.fetchResource(StructureDefinition.class, "http://hl7.org/fhir/StructureDefinition/"+tn);
+ if (sd == null)
+ throw new FHIRException("Unable to find definition for type "+tn);
+ Element res = new Element(property.getName(), property);
+ if (sd.getKind() == StructureDefinitionKind.PRIMITIVETYPE)
+ res.setValue(((PrimitiveType) base).asStringValue());
+
+ List children = ProfileUtilities.getChildMap(sd, sd.getSnapshot().getElementFirstRep());
+ for (ElementDefinition child : children) {
+ String n = tail(child.getPath());
+ if (sd.getKind() != StructureDefinitionKind.PRIMITIVETYPE || !"value".equals(n)) {
+ Base[] values = base.getProperty(n.hashCode(), n, false);
+ if (values != null)
+ for (Base value : values) {
+ res.getChildren().add(convertElement(new Property(context, child, sd), value));
+ }
+ }
+ }
+ return res;
+ }
+
+ private String tail(String path) {
+ if (path.contains("."))
+ return path.substring(path.lastIndexOf('.')+1);
+ else
+ return path;
+ }
+
+
+}
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/ParserBase.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/ParserBase.java
similarity index 96%
rename from hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/ParserBase.java
rename to hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/ParserBase.java
index 1a8fc79ee12..9d2a503fd2c 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/ParserBase.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/ParserBase.java
@@ -1,4 +1,4 @@
-package org.hl7.fhir.dstu3.metamodel;
+package org.hl7.fhir.dstu3.elementmodel;
import java.io.InputStream;
import java.io.OutputStream;
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/Property.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/Property.java
similarity index 95%
rename from hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/Property.java
rename to hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/Property.java
index 92f58044a57..293e38c9cc6 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/Property.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/Property.java
@@ -1,4 +1,4 @@
-package org.hl7.fhir.dstu3.metamodel;
+package org.hl7.fhir.dstu3.elementmodel;
import java.util.ArrayList;
import java.util.List;
@@ -50,6 +50,8 @@ public class Property {
}
public String getType(String elementName) {
+ if (!definition.getPath().contains("."))
+ return definition.getPath();
if (definition.getType().size() == 0)
return null;
else if (definition.getType().size() > 1) {
@@ -114,7 +116,7 @@ public class Property {
}
public boolean isList() {
- return !definition.getMax().equals("1");
+ return !"1".equals(definition.getMax());
}
public String getScopedPropertyName() {
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/TurtleParser.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/TurtleParser.java
new file mode 100644
index 00000000000..55a08b1f3f1
--- /dev/null
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/TurtleParser.java
@@ -0,0 +1,25 @@
+package org.hl7.fhir.dstu3.elementmodel;
+
+import java.io.InputStream;
+import java.io.OutputStream;
+
+import org.hl7.fhir.dstu3.formats.IParser.OutputStyle;
+import org.hl7.fhir.dstu3.utils.IWorkerContext;
+
+public class TurtleParser extends ParserBase {
+
+ public TurtleParser(IWorkerContext theContext) {
+ super(theContext);
+ }
+
+ @Override
+ public Element parse(InputStream theStream) throws Exception {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void compose(Element theE, OutputStream theDestination, OutputStyle theStyle, String theBase) throws Exception {
+ throw new UnsupportedOperationException();
+ }
+
+}
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/XmlParser.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/XmlParser.java
similarity index 95%
rename from hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/XmlParser.java
rename to hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/XmlParser.java
index 9abd334033f..00bb0e103dc 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/metamodel/XmlParser.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/elementmodel/XmlParser.java
@@ -1,4 +1,4 @@
-package org.hl7.fhir.dstu3.metamodel;
+package org.hl7.fhir.dstu3.elementmodel;
import java.io.ByteArrayInputStream;
import java.io.IOException;
@@ -17,10 +17,10 @@ import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.sax.SAXSource;
import org.apache.commons.lang3.NotImplementedException;
+import org.hl7.fhir.dstu3.elementmodel.Element.SpecialElement;
import org.hl7.fhir.dstu3.exceptions.FHIRFormatError;
import org.hl7.fhir.dstu3.formats.FormatUtilities;
import org.hl7.fhir.dstu3.formats.IParser.OutputStyle;
-import org.hl7.fhir.dstu3.metamodel.Element.SpecialElement;
import org.hl7.fhir.dstu3.model.DateTimeType;
import org.hl7.fhir.dstu3.model.ElementDefinition;
import org.hl7.fhir.dstu3.model.ElementDefinition.PropertyRepresentation;
@@ -278,7 +278,7 @@ public class XmlParser extends ParserBase {
context.getChildren().add(n);
if (ok) {
if (property.isResource())
- parseResource(npath, (org.w3c.dom.Element) child, n);
+ parseResource(npath, (org.w3c.dom.Element) child, n, property);
else
parseChildren(npath, (org.w3c.dom.Element) child, n);
}
@@ -327,13 +327,13 @@ public class XmlParser extends ParserBase {
throw new FHIRException("Unknown Data format '"+fmt+"'");
}
- private void parseResource(String string, org.w3c.dom.Element container, Element parent) throws Exception {
+ private void parseResource(String string, org.w3c.dom.Element container, Element parent, Property elementProperty) throws Exception {
org.w3c.dom.Element res = XMLUtil.getFirstChild(container);
String name = res.getLocalName();
StructureDefinition sd = context.fetchResource(StructureDefinition.class, "http://hl7.org/fhir/StructureDefinition/"+name);
if (sd == null)
throw new FHIRFormatError("Contained resource does not appear to be a FHIR resource (unknown name '"+res.getLocalName()+"')");
- parent.updateProperty(new Property(context, sd.getSnapshot().getElement().get(0), sd), parent.getProperty().getName().equals("contained") ? SpecialElement.CONTAINED : SpecialElement.BUNDLE_ENTRY);
+ parent.updateProperty(new Property(context, sd.getSnapshot().getElement().get(0), sd), SpecialElement.fromProperty(parent.getProperty()), elementProperty);
parent.setType(name);
parseChildren(res.getLocalName(), res, parent);
}
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/formats/JsonParser.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/formats/JsonParser.java
new file mode 100644
index 00000000000..e46d061f2e8
--- /dev/null
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/formats/JsonParser.java
@@ -0,0 +1,13 @@
+package org.hl7.fhir.dstu3.formats;
+
+import java.io.ByteArrayOutputStream;
+
+import org.hl7.fhir.dstu3.model.Resource;
+
+public class JsonParser {
+
+ public void compose(ByteArrayOutputStream theBs, Resource theIg) {
+ throw new UnsupportedOperationException();
+ }
+
+}
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/formats/XmlParser.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/formats/XmlParser.java
deleted file mode 100644
index 2f79701d6d7..00000000000
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/formats/XmlParser.java
+++ /dev/null
@@ -1,34548 +0,0 @@
-package org.hl7.fhir.dstu3.formats;
-
-/*
- Copyright (c) 2011+, HL7, Inc.
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without modification,
- are permitted provided that the following conditions are met:
-
- * Redistributions of source code must retain the above copyright notice, this
- list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
- and/or other materials provided with the distribution.
- * Neither the name of HL7 nor the names of its contributors may be used to
- endorse or promote products derived from this software without specific
- prior written permission.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
- IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
- INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
- PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
- WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
- POSSIBILITY OF SUCH DAMAGE.
-
-*/
-
-// Generated on Fri, May 27, 2016 13:57-0400 for FHIR v1.4.0
-
-import org.hl7.fhir.dstu3.model.DateType;
-import org.hl7.fhir.dstu3.model.DateTimeType;
-import org.hl7.fhir.dstu3.model.CodeType;
-import org.hl7.fhir.dstu3.model.StringType;
-import org.hl7.fhir.dstu3.model.IntegerType;
-import org.hl7.fhir.dstu3.model.OidType;
-import org.hl7.fhir.dstu3.model.UriType;
-import org.hl7.fhir.dstu3.model.UuidType;
-import org.hl7.fhir.dstu3.model.InstantType;
-import org.hl7.fhir.dstu3.model.BooleanType;
-import org.hl7.fhir.dstu3.model.Base64BinaryType;
-import org.hl7.fhir.dstu3.model.UnsignedIntType;
-import org.hl7.fhir.dstu3.model.MarkdownType;
-import org.hl7.fhir.dstu3.model.TimeType;
-import org.hl7.fhir.dstu3.model.IdType;
-import org.hl7.fhir.dstu3.model.PositiveIntType;
-import org.hl7.fhir.dstu3.model.DecimalType;
-import org.hl7.fhir.dstu3.model.*;
-import org.xmlpull.v1.*;
-import org.hl7.fhir.utilities.Utilities;
-import org.hl7.fhir.dstu3.exceptions.FHIRFormatError;
-import org.hl7.fhir.dstu3.exceptions.FHIRException;
-import java.io.IOException;
-
-public class XmlParser extends XmlParserBase {
-
- public XmlParser() {
- super();
- }
-
- public XmlParser(boolean allowUnknownContent) {
- super();
- setAllowUnknownContent(allowUnknownContent);
- }
-
-
- protected boolean parseElementContent(int eventType, XmlPullParser xpp, Element res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("extension"))
- res.getExtension().add(parseExtension(xpp));
- else
- return false;
-
- return true;
- }
-
- protected boolean parseBackboneContent(int eventType, XmlPullParser xpp, BackboneElement res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("modifierExtension"))
- res.getModifierExtension().add(parseExtension(xpp));
- else
- return parseElementContent(eventType, xpp, res);
-
- return true;
- }
-
- @SuppressWarnings("unchecked")
- protected > Enumeration parseEnumeration(XmlPullParser xpp, E item, EnumFactory e) throws XmlPullParserException, IOException, FHIRFormatError {
- Enumeration res = new Enumeration(e);
- parseElementAttributes(xpp, res);
- res.setValue((E) e.fromCode(xpp.getAttributeValue(null, "value")));
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected DateType parseDate(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DateType res = new DateType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected DateTimeType parseDateTime(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DateTimeType res = new DateTimeType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected CodeType parseCode(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- CodeType res = new CodeType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected StringType parseString(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- StringType res = new StringType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected IntegerType parseInteger(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- IntegerType res = new IntegerType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected OidType parseOid(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- OidType res = new OidType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected UriType parseUri(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- UriType res = new UriType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected UuidType parseUuid(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- UuidType res = new UuidType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected InstantType parseInstant(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- InstantType res = new InstantType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected BooleanType parseBoolean(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- BooleanType res = new BooleanType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected Base64BinaryType parseBase64Binary(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Base64BinaryType res = new Base64BinaryType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected UnsignedIntType parseUnsignedInt(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- UnsignedIntType res = new UnsignedIntType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected MarkdownType parseMarkdown(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- MarkdownType res = new MarkdownType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected TimeType parseTime(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- TimeType res = new TimeType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected IdType parseId(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- IdType res = new IdType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected PositiveIntType parsePositiveInt(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- PositiveIntType res = new PositiveIntType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected DecimalType parseDecimal(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DecimalType res = new DecimalType(xpp.getAttributeValue(null, "value"));
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected Extension parseExtension(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Extension res = new Extension();
- parseElementAttributes(xpp, res);
- if (xpp.getAttributeValue(null, "url") != null)
- res.setUrl(xpp.getAttributeValue(null, "url"));
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExtensionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExtensionContent(int eventType, XmlPullParser xpp, Extension res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Narrative parseNarrative(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Narrative res = new Narrative();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseNarrativeContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseNarrativeContent(int eventType, XmlPullParser xpp, Narrative res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Narrative.NarrativeStatus.NULL, new Narrative.NarrativeStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("div")) {
- res.setDiv(parseXhtml(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Reference parseReference(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Reference res = new Reference();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseReferenceContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseReferenceContent(int eventType, XmlPullParser xpp, Reference res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reference")) {
- res.setReferenceElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("display")) {
- res.setDisplayElement(parseString(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Quantity parseQuantity(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Quantity res = new Quantity();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseQuantityContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseQuantityContent(int eventType, XmlPullParser xpp, Quantity res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comparator")) {
- res.setComparatorElement(parseEnumeration(xpp, Quantity.QuantityComparator.NULL, new Quantity.QuantityComparatorEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unit")) {
- res.setUnitElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Period parsePeriod(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Period res = new Period();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePeriodContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePeriodContent(int eventType, XmlPullParser xpp, Period res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("start")) {
- res.setStartElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("end")) {
- res.setEndElement(parseDateTime(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Attachment parseAttachment(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Attachment res = new Attachment();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAttachmentContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAttachmentContent(int eventType, XmlPullParser xpp, Attachment res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contentType")) {
- res.setContentTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("language")) {
- res.setLanguageElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("data")) {
- res.setDataElement(parseBase64Binary(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("size")) {
- res.setSizeElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("hash")) {
- res.setHashElement(parseBase64Binary(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("title")) {
- res.setTitleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("creation")) {
- res.setCreationElement(parseDateTime(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Duration parseDuration(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Duration res = new Duration();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDurationContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDurationContent(int eventType, XmlPullParser xpp, Duration res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (!parseQuantityContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Count parseCount(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Count res = new Count();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCountContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCountContent(int eventType, XmlPullParser xpp, Count res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (!parseQuantityContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Range parseRange(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Range res = new Range();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseRangeContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseRangeContent(int eventType, XmlPullParser xpp, Range res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("low")) {
- res.setLow(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("high")) {
- res.setHigh(parseSimpleQuantity(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Annotation parseAnnotation(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Annotation res = new Annotation();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAnnotationContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAnnotationContent(int eventType, XmlPullParser xpp, Annotation res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "author")) {
- res.setAuthor(parseType("author", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("time")) {
- res.setTimeElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Money parseMoney(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Money res = new Money();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMoneyContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMoneyContent(int eventType, XmlPullParser xpp, Money res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (!parseQuantityContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Identifier parseIdentifier(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Identifier res = new Identifier();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseIdentifierContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseIdentifierContent(int eventType, XmlPullParser xpp, Identifier res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUseElement(parseEnumeration(xpp, Identifier.IdentifierUse.NULL, new Identifier.IdentifierUseEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("assigner")) {
- res.setAssigner(parseReference(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Coding parseCoding(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Coding res = new Coding();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCodingContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCodingContent(int eventType, XmlPullParser xpp, Coding res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("display")) {
- res.setDisplayElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("userSelected")) {
- res.setUserSelectedElement(parseBoolean(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Signature parseSignature(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Signature res = new Signature();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSignatureContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSignatureContent(int eventType, XmlPullParser xpp, Signature res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("when")) {
- res.setWhenElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "who")) {
- res.setWho(parseType("who", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contentType")) {
- res.setContentTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("blob")) {
- res.setBlobElement(parseBase64Binary(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected SampledData parseSampledData(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- SampledData res = new SampledData();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSampledDataContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSampledDataContent(int eventType, XmlPullParser xpp, SampledData res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("origin")) {
- res.setOrigin(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriodElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("factor")) {
- res.setFactorElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lowerLimit")) {
- res.setLowerLimitElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("upperLimit")) {
- res.setUpperLimitElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dimensions")) {
- res.setDimensionsElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("data")) {
- res.setDataElement(parseString(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Ratio parseRatio(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Ratio res = new Ratio();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseRatioContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseRatioContent(int eventType, XmlPullParser xpp, Ratio res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("numerator")) {
- res.setNumerator(parseQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("denominator")) {
- res.setDenominator(parseQuantity(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Distance parseDistance(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Distance res = new Distance();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDistanceContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDistanceContent(int eventType, XmlPullParser xpp, Distance res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (!parseQuantityContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Age parseAge(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Age res = new Age();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAgeContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAgeContent(int eventType, XmlPullParser xpp, Age res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (!parseQuantityContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CodeableConcept parseCodeableConcept(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- CodeableConcept res = new CodeableConcept();
- parseTypeAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCodeableConceptContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCodeableConceptContent(int eventType, XmlPullParser xpp, CodeableConcept res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("coding")) {
- res.getCoding().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected SimpleQuantity parseSimpleQuantity(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- SimpleQuantity res = new SimpleQuantity();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSimpleQuantityContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSimpleQuantityContent(int eventType, XmlPullParser xpp, SimpleQuantity res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comparator")) {
- res.setComparatorElement(parseEnumeration(xpp, Quantity.QuantityComparator.NULL, new Quantity.QuantityComparatorEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unit")) {
- res.setUnitElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected HumanName parseHumanName(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- HumanName res = new HumanName();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseHumanNameContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseHumanNameContent(int eventType, XmlPullParser xpp, HumanName res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUseElement(parseEnumeration(xpp, HumanName.NameUse.NULL, new HumanName.NameUseEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("family")) {
- res.getFamily().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("given")) {
- res.getGiven().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prefix")) {
- res.getPrefix().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("suffix")) {
- res.getSuffix().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ContactPoint parseContactPoint(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ContactPoint res = new ContactPoint();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseContactPointContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseContactPointContent(int eventType, XmlPullParser xpp, ContactPoint res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseEnumeration(xpp, ContactPoint.ContactPointSystem.NULL, new ContactPoint.ContactPointSystemEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUseElement(parseEnumeration(xpp, ContactPoint.ContactPointUse.NULL, new ContactPoint.ContactPointUseEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rank")) {
- res.setRankElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Meta parseMeta(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Meta res = new Meta();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMetaContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMetaContent(int eventType, XmlPullParser xpp, Meta res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("versionId")) {
- res.setVersionIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lastUpdated")) {
- res.setLastUpdatedElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.getProfile().add(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("security")) {
- res.getSecurity().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("tag")) {
- res.getTag().add(parseCoding(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Address parseAddress(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Address res = new Address();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAddressContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAddressContent(int eventType, XmlPullParser xpp, Address res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUseElement(parseEnumeration(xpp, Address.AddressUse.NULL, new Address.AddressUseEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Address.AddressType.NULL, new Address.AddressTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("line")) {
- res.getLine().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("city")) {
- res.setCityElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("district")) {
- res.setDistrictElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("state")) {
- res.setStateElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("postalCode")) {
- res.setPostalCodeElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("country")) {
- res.setCountryElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TriggerDefinition parseTriggerDefinition(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- TriggerDefinition res = new TriggerDefinition();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTriggerDefinitionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTriggerDefinitionContent(int eventType, XmlPullParser xpp, TriggerDefinition res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, TriggerDefinition.TriggerType.NULL, new TriggerDefinition.TriggerTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("eventName")) {
- res.setEventNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "eventTiming")) {
- res.setEventTiming(parseType("eventTiming", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("eventData")) {
- res.setEventData(parseDataRequirement(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleMetadata parseModuleMetadata(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleMetadata res = new ModuleMetadata();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleMetadataContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleMetadataContent(int eventType, XmlPullParser xpp, ModuleMetadata res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("title")) {
- res.setTitleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, ModuleMetadata.ModuleMetadataType.NULL, new ModuleMetadata.ModuleMetadataTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, ModuleMetadata.ModuleMetadataStatus.NULL, new ModuleMetadata.ModuleMetadataStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("purpose")) {
- res.setPurposeElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("usage")) {
- res.setUsageElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publicationDate")) {
- res.setPublicationDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lastReviewDate")) {
- res.setLastReviewDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("effectivePeriod")) {
- res.setEffectivePeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("coverage")) {
- res.getCoverage().add(parseModuleMetadataModuleMetadataCoverageComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("topic")) {
- res.getTopic().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contributor")) {
- res.getContributor().add(parseModuleMetadataModuleMetadataContributorComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseModuleMetadataModuleMetadataContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("copyright")) {
- res.setCopyrightElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relatedResource")) {
- res.getRelatedResource().add(parseModuleMetadataModuleMetadataRelatedResourceComponent(xpp, res));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleMetadata.ModuleMetadataCoverageComponent parseModuleMetadataModuleMetadataCoverageComponent(XmlPullParser xpp, ModuleMetadata owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleMetadata.ModuleMetadataCoverageComponent res = new ModuleMetadata.ModuleMetadataCoverageComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleMetadataModuleMetadataCoverageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleMetadataModuleMetadataCoverageComponentContent(int eventType, XmlPullParser xpp, ModuleMetadata owner, ModuleMetadata.ModuleMetadataCoverageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("focus")) {
- res.setFocus(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValue(parseCodeableConcept(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleMetadata.ModuleMetadataContributorComponent parseModuleMetadataModuleMetadataContributorComponent(XmlPullParser xpp, ModuleMetadata owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleMetadata.ModuleMetadataContributorComponent res = new ModuleMetadata.ModuleMetadataContributorComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleMetadataModuleMetadataContributorComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleMetadataModuleMetadataContributorComponentContent(int eventType, XmlPullParser xpp, ModuleMetadata owner, ModuleMetadata.ModuleMetadataContributorComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, ModuleMetadata.ModuleMetadataContributorType.NULL, new ModuleMetadata.ModuleMetadataContributorTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseModuleMetadataModuleMetadataContributorContactComponent(xpp, owner));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleMetadata.ModuleMetadataContributorContactComponent parseModuleMetadataModuleMetadataContributorContactComponent(XmlPullParser xpp, ModuleMetadata owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleMetadata.ModuleMetadataContributorContactComponent res = new ModuleMetadata.ModuleMetadataContributorContactComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleMetadataModuleMetadataContributorContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleMetadataModuleMetadataContributorContactComponentContent(int eventType, XmlPullParser xpp, ModuleMetadata owner, ModuleMetadata.ModuleMetadataContributorContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleMetadata.ModuleMetadataContactComponent parseModuleMetadataModuleMetadataContactComponent(XmlPullParser xpp, ModuleMetadata owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleMetadata.ModuleMetadataContactComponent res = new ModuleMetadata.ModuleMetadataContactComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleMetadataModuleMetadataContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleMetadataModuleMetadataContactComponentContent(int eventType, XmlPullParser xpp, ModuleMetadata owner, ModuleMetadata.ModuleMetadataContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleMetadata.ModuleMetadataRelatedResourceComponent parseModuleMetadataModuleMetadataRelatedResourceComponent(XmlPullParser xpp, ModuleMetadata owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleMetadata.ModuleMetadataRelatedResourceComponent res = new ModuleMetadata.ModuleMetadataRelatedResourceComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleMetadataModuleMetadataRelatedResourceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleMetadataModuleMetadataRelatedResourceComponentContent(int eventType, XmlPullParser xpp, ModuleMetadata owner, ModuleMetadata.ModuleMetadataRelatedResourceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, ModuleMetadata.ModuleMetadataResourceType.NULL, new ModuleMetadata.ModuleMetadataResourceTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("document")) {
- res.setDocument(parseAttachment(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.setResource(parseReference(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Timing parseTiming(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Timing res = new Timing();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTimingContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTimingContent(int eventType, XmlPullParser xpp, Timing res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("event")) {
- res.getEvent().add(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("repeat")) {
- res.setRepeat(parseTimingTimingRepeatComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Timing.TimingRepeatComponent parseTimingTimingRepeatComponent(XmlPullParser xpp, Timing owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Timing.TimingRepeatComponent res = new Timing.TimingRepeatComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTimingTimingRepeatComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTimingTimingRepeatComponentContent(int eventType, XmlPullParser xpp, Timing owner, Timing.TimingRepeatComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "bounds")) {
- res.setBounds(parseType("bounds", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("count")) {
- res.setCountElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("countMax")) {
- res.setCountMaxElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("duration")) {
- res.setDurationElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("durationMax")) {
- res.setDurationMaxElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("durationUnit")) {
- res.setDurationUnitElement(parseEnumeration(xpp, Timing.UnitsOfTime.NULL, new Timing.UnitsOfTimeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("frequency")) {
- res.setFrequencyElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("frequencyMax")) {
- res.setFrequencyMaxElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriodElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("periodMax")) {
- res.setPeriodMaxElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("periodUnit")) {
- res.setPeriodUnitElement(parseEnumeration(xpp, Timing.UnitsOfTime.NULL, new Timing.UnitsOfTimeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("when")) {
- res.setWhenElement(parseEnumeration(xpp, Timing.EventTiming.NULL, new Timing.EventTimingEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("offset")) {
- res.setOffsetElement(parseUnsignedInt(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ElementDefinition parseElementDefinition(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ElementDefinition res = new ElementDefinition();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementDefinitionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseElementDefinitionContent(int eventType, XmlPullParser xpp, ElementDefinition res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("path")) {
- res.setPathElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("representation")) {
- res.getRepresentation().add(parseEnumeration(xpp, ElementDefinition.PropertyRepresentation.NULL, new ElementDefinition.PropertyRepresentationEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("label")) {
- res.setLabelElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.getCode().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("slicing")) {
- res.setSlicing(parseElementDefinitionElementDefinitionSlicingComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("short")) {
- res.setShortElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("definition")) {
- res.setDefinitionElement(parseMarkdown(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comments")) {
- res.setCommentsElement(parseMarkdown(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseMarkdown(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("alias")) {
- res.getAlias().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("min")) {
- res.setMinElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("max")) {
- res.setMaxElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("base")) {
- res.setBase(parseElementDefinitionElementDefinitionBaseComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contentReference")) {
- res.setContentReferenceElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseElementDefinitionTypeRefComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "defaultValue")) {
- res.setDefaultValue(parseType("defaultValue", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("meaningWhenMissing")) {
- res.setMeaningWhenMissingElement(parseMarkdown(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "fixed")) {
- res.setFixed(parseType("fixed", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "pattern")) {
- res.setPattern(parseType("pattern", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "example")) {
- res.setExample(parseType("example", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "minValue")) {
- res.setMinValue(parseType("minValue", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "maxValue")) {
- res.setMaxValue(parseType("maxValue", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("maxLength")) {
- res.setMaxLengthElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("condition")) {
- res.getCondition().add(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("constraint")) {
- res.getConstraint().add(parseElementDefinitionElementDefinitionConstraintComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mustSupport")) {
- res.setMustSupportElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("isModifier")) {
- res.setIsModifierElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("isSummary")) {
- res.setIsSummaryElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("binding")) {
- res.setBinding(parseElementDefinitionElementDefinitionBindingComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mapping")) {
- res.getMapping().add(parseElementDefinitionElementDefinitionMappingComponent(xpp, res));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ElementDefinition.ElementDefinitionSlicingComponent parseElementDefinitionElementDefinitionSlicingComponent(XmlPullParser xpp, ElementDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ElementDefinition.ElementDefinitionSlicingComponent res = new ElementDefinition.ElementDefinitionSlicingComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementDefinitionElementDefinitionSlicingComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseElementDefinitionElementDefinitionSlicingComponentContent(int eventType, XmlPullParser xpp, ElementDefinition owner, ElementDefinition.ElementDefinitionSlicingComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("discriminator")) {
- res.getDiscriminator().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ordered")) {
- res.setOrderedElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rules")) {
- res.setRulesElement(parseEnumeration(xpp, ElementDefinition.SlicingRules.NULL, new ElementDefinition.SlicingRulesEnumFactory()));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ElementDefinition.ElementDefinitionBaseComponent parseElementDefinitionElementDefinitionBaseComponent(XmlPullParser xpp, ElementDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ElementDefinition.ElementDefinitionBaseComponent res = new ElementDefinition.ElementDefinitionBaseComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementDefinitionElementDefinitionBaseComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseElementDefinitionElementDefinitionBaseComponentContent(int eventType, XmlPullParser xpp, ElementDefinition owner, ElementDefinition.ElementDefinitionBaseComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("path")) {
- res.setPathElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("min")) {
- res.setMinElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("max")) {
- res.setMaxElement(parseString(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ElementDefinition.TypeRefComponent parseElementDefinitionTypeRefComponent(XmlPullParser xpp, ElementDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ElementDefinition.TypeRefComponent res = new ElementDefinition.TypeRefComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementDefinitionTypeRefComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseElementDefinitionTypeRefComponentContent(int eventType, XmlPullParser xpp, ElementDefinition owner, ElementDefinition.TypeRefComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.getProfile().add(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("aggregation")) {
- res.getAggregation().add(parseEnumeration(xpp, ElementDefinition.AggregationMode.NULL, new ElementDefinition.AggregationModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("versioning")) {
- res.setVersioningElement(parseEnumeration(xpp, ElementDefinition.ReferenceVersionRules.NULL, new ElementDefinition.ReferenceVersionRulesEnumFactory()));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ElementDefinition.ElementDefinitionConstraintComponent parseElementDefinitionElementDefinitionConstraintComponent(XmlPullParser xpp, ElementDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ElementDefinition.ElementDefinitionConstraintComponent res = new ElementDefinition.ElementDefinitionConstraintComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementDefinitionElementDefinitionConstraintComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseElementDefinitionElementDefinitionConstraintComponentContent(int eventType, XmlPullParser xpp, ElementDefinition owner, ElementDefinition.ElementDefinitionConstraintComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("key")) {
- res.setKeyElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("severity")) {
- res.setSeverityElement(parseEnumeration(xpp, ElementDefinition.ConstraintSeverity.NULL, new ElementDefinition.ConstraintSeverityEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("human")) {
- res.setHumanElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("expression")) {
- res.setExpressionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("xpath")) {
- res.setXpathElement(parseString(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ElementDefinition.ElementDefinitionBindingComponent parseElementDefinitionElementDefinitionBindingComponent(XmlPullParser xpp, ElementDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ElementDefinition.ElementDefinitionBindingComponent res = new ElementDefinition.ElementDefinitionBindingComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementDefinitionElementDefinitionBindingComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseElementDefinitionElementDefinitionBindingComponentContent(int eventType, XmlPullParser xpp, ElementDefinition owner, ElementDefinition.ElementDefinitionBindingComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("strength")) {
- res.setStrengthElement(parseEnumeration(xpp, Enumerations.BindingStrength.NULL, new Enumerations.BindingStrengthEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "valueSet")) {
- res.setValueSet(parseType("valueSet", xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ElementDefinition.ElementDefinitionMappingComponent parseElementDefinitionElementDefinitionMappingComponent(XmlPullParser xpp, ElementDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ElementDefinition.ElementDefinitionMappingComponent res = new ElementDefinition.ElementDefinitionMappingComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseElementDefinitionElementDefinitionMappingComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseElementDefinitionElementDefinitionMappingComponentContent(int eventType, XmlPullParser xpp, ElementDefinition owner, ElementDefinition.ElementDefinitionMappingComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identity")) {
- res.setIdentityElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("language")) {
- res.setLanguageElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("map")) {
- res.setMapElement(parseString(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DataRequirement parseDataRequirement(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DataRequirement res = new DataRequirement();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDataRequirementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDataRequirementContent(int eventType, XmlPullParser xpp, DataRequirement res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.setProfile(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mustSupport")) {
- res.getMustSupport().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("codeFilter")) {
- res.getCodeFilter().add(parseDataRequirementDataRequirementCodeFilterComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateFilter")) {
- res.getDateFilter().add(parseDataRequirementDataRequirementDateFilterComponent(xpp, res));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DataRequirement.DataRequirementCodeFilterComponent parseDataRequirementDataRequirementCodeFilterComponent(XmlPullParser xpp, DataRequirement owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DataRequirement.DataRequirementCodeFilterComponent res = new DataRequirement.DataRequirementCodeFilterComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDataRequirementDataRequirementCodeFilterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDataRequirementDataRequirementCodeFilterComponentContent(int eventType, XmlPullParser xpp, DataRequirement owner, DataRequirement.DataRequirementCodeFilterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("path")) {
- res.setPathElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "valueSet")) {
- res.setValueSet(parseType("valueSet", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("valueCode")) {
- res.getValueCode().add(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("valueCoding")) {
- res.getValueCoding().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("valueCodeableConcept")) {
- res.getValueCodeableConcept().add(parseCodeableConcept(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DataRequirement.DataRequirementDateFilterComponent parseDataRequirementDataRequirementDateFilterComponent(XmlPullParser xpp, DataRequirement owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DataRequirement.DataRequirementDateFilterComponent res = new DataRequirement.DataRequirementDateFilterComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDataRequirementDataRequirementDateFilterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDataRequirementDataRequirementDateFilterComponentContent(int eventType, XmlPullParser xpp, DataRequirement owner, DataRequirement.DataRequirementDateFilterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("path")) {
- res.setPathElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ActionDefinition parseActionDefinition(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ActionDefinition res = new ActionDefinition();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseActionDefinitionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseActionDefinitionContent(int eventType, XmlPullParser xpp, ActionDefinition res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actionIdentifier")) {
- res.setActionIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("label")) {
- res.setLabelElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("title")) {
- res.setTitleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("textEquivalent")) {
- res.setTextEquivalentElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("concept")) {
- res.getConcept().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supportingEvidence")) {
- res.getSupportingEvidence().add(parseAttachment(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.getDocumentation().add(parseAttachment(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relatedAction")) {
- res.setRelatedAction(parseActionDefinitionActionDefinitionRelatedActionComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("participantType")) {
- res.getParticipantType().add(parseEnumeration(xpp, ActionDefinition.ParticipantType.NULL, new ActionDefinition.ParticipantTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, ActionDefinition.ActionType.NULL, new ActionDefinition.ActionTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("behavior")) {
- res.getBehavior().add(parseActionDefinitionActionDefinitionBehaviorComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.setResource(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("customization")) {
- res.getCustomization().add(parseActionDefinitionActionDefinitionCustomizationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseActionDefinition(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ActionDefinition.ActionDefinitionRelatedActionComponent parseActionDefinitionActionDefinitionRelatedActionComponent(XmlPullParser xpp, ActionDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ActionDefinition.ActionDefinitionRelatedActionComponent res = new ActionDefinition.ActionDefinitionRelatedActionComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseActionDefinitionActionDefinitionRelatedActionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseActionDefinitionActionDefinitionRelatedActionComponentContent(int eventType, XmlPullParser xpp, ActionDefinition owner, ActionDefinition.ActionDefinitionRelatedActionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actionIdentifier")) {
- res.setActionIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relationship")) {
- res.setRelationshipElement(parseEnumeration(xpp, ActionDefinition.ActionRelationshipType.NULL, new ActionDefinition.ActionRelationshipTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "offset")) {
- res.setOffset(parseType("offset", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("anchor")) {
- res.setAnchorElement(parseEnumeration(xpp, ActionDefinition.ActionRelationshipAnchor.NULL, new ActionDefinition.ActionRelationshipAnchorEnumFactory()));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ActionDefinition.ActionDefinitionBehaviorComponent parseActionDefinitionActionDefinitionBehaviorComponent(XmlPullParser xpp, ActionDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ActionDefinition.ActionDefinitionBehaviorComponent res = new ActionDefinition.ActionDefinitionBehaviorComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseActionDefinitionActionDefinitionBehaviorComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseActionDefinitionActionDefinitionBehaviorComponentContent(int eventType, XmlPullParser xpp, ActionDefinition owner, ActionDefinition.ActionDefinitionBehaviorComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValue(parseCoding(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ActionDefinition.ActionDefinitionCustomizationComponent parseActionDefinitionActionDefinitionCustomizationComponent(XmlPullParser xpp, ActionDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ActionDefinition.ActionDefinitionCustomizationComponent res = new ActionDefinition.ActionDefinitionCustomizationComponent();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseActionDefinitionActionDefinitionCustomizationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseActionDefinitionActionDefinitionCustomizationComponentContent(int eventType, XmlPullParser xpp, ActionDefinition owner, ActionDefinition.ActionDefinitionCustomizationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("path")) {
- res.setPathElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("expression")) {
- res.setExpressionElement(parseString(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ParameterDefinition parseParameterDefinition(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ParameterDefinition res = new ParameterDefinition();
- parseElementAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseParameterDefinitionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseParameterDefinitionContent(int eventType, XmlPullParser xpp, ParameterDefinition res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUseElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("min")) {
- res.setMinElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("max")) {
- res.setMaxElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.setProfile(parseReference(xpp));
- } else if (!parseElementContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected void parseDomainResourceAttributes(XmlPullParser xpp, DomainResource res) throws XmlPullParserException, IOException, FHIRFormatError {
- parseResourceAttributes(xpp, res);
- }
-
- protected boolean parseDomainResourceContent(int eventType, XmlPullParser xpp, DomainResource res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setText(parseNarrative(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contained")) {
- res.getContained().add(parseResourceContained(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("extension")) {
- res.getExtension().add(parseExtension(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("modifierExtension")) {
- res.getModifierExtension().add(parseExtension(xpp));
- } else
- return parseResourceContent(eventType, xpp, res);
- return true;
- }
-
- protected Parameters parseParameters(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Parameters res = new Parameters();
- parseResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseParametersContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseParametersContent(int eventType, XmlPullParser xpp, Parameters res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parameter")) {
- res.getParameter().add(parseParametersParametersParameterComponent(xpp, res));
- } else if (!parseResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Parameters.ParametersParameterComponent parseParametersParametersParameterComponent(XmlPullParser xpp, Parameters owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Parameters.ParametersParameterComponent res = new Parameters.ParametersParameterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseParametersParametersParameterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseParametersParametersParameterComponentContent(int eventType, XmlPullParser xpp, Parameters owner, Parameters.ParametersParameterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.setResource(parseResourceContained(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("part")) {
- res.getPart().add(parseParametersParametersParameterComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected void parseResourceAttributes(XmlPullParser xpp, Resource res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (!comments.isEmpty()) {
- res.getFormatCommentsPre().addAll(comments);
- comments.clear();
- }
- }
-
- protected boolean parseResourceContent(int eventType, XmlPullParser xpp, Resource res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("id")) {
- res.setIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("meta")) {
- res.setMeta(parseMeta(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("implicitRules")) {
- res.setImplicitRulesElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("language")) {
- res.setLanguageElement(parseCode(xpp));
- } else
- return false;
- return true;
- }
-
- protected Account parseAccount(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Account res = new Account();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAccountContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAccountContent(int eventType, XmlPullParser xpp, Account res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Account.AccountStatus.NULL, new Account.AccountStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("activePeriod")) {
- res.setActivePeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("currency")) {
- res.setCurrency(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("balance")) {
- res.setBalance(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("coveragePeriod")) {
- res.setCoveragePeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("owner")) {
- res.setOwner(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected AllergyIntolerance parseAllergyIntolerance(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- AllergyIntolerance res = new AllergyIntolerance();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAllergyIntoleranceContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAllergyIntoleranceContent(int eventType, XmlPullParser xpp, AllergyIntolerance res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, AllergyIntolerance.AllergyIntoleranceStatus.NULL, new AllergyIntolerance.AllergyIntoleranceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, AllergyIntolerance.AllergyIntoleranceType.NULL, new AllergyIntolerance.AllergyIntoleranceTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategoryElement(parseEnumeration(xpp, AllergyIntolerance.AllergyIntoleranceCategory.NULL, new AllergyIntolerance.AllergyIntoleranceCategoryEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("criticality")) {
- res.setCriticalityElement(parseEnumeration(xpp, AllergyIntolerance.AllergyIntoleranceCriticality.NULL, new AllergyIntolerance.AllergyIntoleranceCriticalityEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("substance")) {
- res.setSubstance(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recordedDate")) {
- res.setRecordedDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recorder")) {
- res.setRecorder(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reporter")) {
- res.setReporter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("onset")) {
- res.setOnsetElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lastOccurence")) {
- res.setLastOccurenceElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reaction")) {
- res.getReaction().add(parseAllergyIntoleranceAllergyIntoleranceReactionComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected AllergyIntolerance.AllergyIntoleranceReactionComponent parseAllergyIntoleranceAllergyIntoleranceReactionComponent(XmlPullParser xpp, AllergyIntolerance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- AllergyIntolerance.AllergyIntoleranceReactionComponent res = new AllergyIntolerance.AllergyIntoleranceReactionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAllergyIntoleranceAllergyIntoleranceReactionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAllergyIntoleranceAllergyIntoleranceReactionComponentContent(int eventType, XmlPullParser xpp, AllergyIntolerance owner, AllergyIntolerance.AllergyIntoleranceReactionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("substance")) {
- res.setSubstance(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("certainty")) {
- res.setCertaintyElement(parseEnumeration(xpp, AllergyIntolerance.AllergyIntoleranceCertainty.NULL, new AllergyIntolerance.AllergyIntoleranceCertaintyEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("manifestation")) {
- res.getManifestation().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("onset")) {
- res.setOnsetElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("severity")) {
- res.setSeverityElement(parseEnumeration(xpp, AllergyIntolerance.AllergyIntoleranceSeverity.NULL, new AllergyIntolerance.AllergyIntoleranceSeverityEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("exposureRoute")) {
- res.setExposureRoute(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Appointment parseAppointment(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Appointment res = new Appointment();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAppointmentContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAppointmentContent(int eventType, XmlPullParser xpp, Appointment res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Appointment.AppointmentStatus.NULL, new Appointment.AppointmentStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceCategory")) {
- res.setServiceCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceType")) {
- res.getServiceType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specialty")) {
- res.getSpecialty().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("appointmentType")) {
- res.setAppointmentType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priority")) {
- res.setPriorityElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("start")) {
- res.setStartElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("end")) {
- res.setEndElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("minutesDuration")) {
- res.setMinutesDurationElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("slot")) {
- res.getSlot().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comment")) {
- res.setCommentElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("participant")) {
- res.getParticipant().add(parseAppointmentAppointmentParticipantComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Appointment.AppointmentParticipantComponent parseAppointmentAppointmentParticipantComponent(XmlPullParser xpp, Appointment owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Appointment.AppointmentParticipantComponent res = new Appointment.AppointmentParticipantComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAppointmentAppointmentParticipantComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAppointmentAppointmentParticipantComponentContent(int eventType, XmlPullParser xpp, Appointment owner, Appointment.AppointmentParticipantComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("required")) {
- res.setRequiredElement(parseEnumeration(xpp, Appointment.ParticipantRequired.NULL, new Appointment.ParticipantRequiredEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Appointment.ParticipationStatus.NULL, new Appointment.ParticipationStatusEnumFactory()));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected AppointmentResponse parseAppointmentResponse(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- AppointmentResponse res = new AppointmentResponse();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAppointmentResponseContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAppointmentResponseContent(int eventType, XmlPullParser xpp, AppointmentResponse res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("appointment")) {
- res.setAppointment(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("start")) {
- res.setStartElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("end")) {
- res.setEndElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("participantType")) {
- res.getParticipantType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("participantStatus")) {
- res.setParticipantStatusElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comment")) {
- res.setCommentElement(parseString(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected AuditEvent parseAuditEvent(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- AuditEvent res = new AuditEvent();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAuditEventContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAuditEventContent(int eventType, XmlPullParser xpp, AuditEvent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subtype")) {
- res.getSubtype().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.setActionElement(parseEnumeration(xpp, AuditEvent.AuditEventAction.NULL, new AuditEvent.AuditEventActionEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recorded")) {
- res.setRecordedElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outcome")) {
- res.setOutcomeElement(parseEnumeration(xpp, AuditEvent.AuditEventOutcome.NULL, new AuditEvent.AuditEventOutcomeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outcomeDesc")) {
- res.setOutcomeDescElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("purposeOfEvent")) {
- res.getPurposeOfEvent().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("agent")) {
- res.getAgent().add(parseAuditEventAuditEventAgentComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("source")) {
- res.setSource(parseAuditEventAuditEventSourceComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("entity")) {
- res.getEntity().add(parseAuditEventAuditEventEntityComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected AuditEvent.AuditEventAgentComponent parseAuditEventAuditEventAgentComponent(XmlPullParser xpp, AuditEvent owner) throws XmlPullParserException, IOException, FHIRFormatError {
- AuditEvent.AuditEventAgentComponent res = new AuditEvent.AuditEventAgentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAuditEventAuditEventAgentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAuditEventAuditEventAgentComponentContent(int eventType, XmlPullParser xpp, AuditEvent owner, AuditEvent.AuditEventAgentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.getRole().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reference")) {
- res.setReference(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("userId")) {
- res.setUserId(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("altId")) {
- res.setAltIdElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requestor")) {
- res.setRequestorElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.setLocation(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("policy")) {
- res.getPolicy().add(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("media")) {
- res.setMedia(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("network")) {
- res.setNetwork(parseAuditEventAuditEventAgentNetworkComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("purposeOfUse")) {
- res.getPurposeOfUse().add(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected AuditEvent.AuditEventAgentNetworkComponent parseAuditEventAuditEventAgentNetworkComponent(XmlPullParser xpp, AuditEvent owner) throws XmlPullParserException, IOException, FHIRFormatError {
- AuditEvent.AuditEventAgentNetworkComponent res = new AuditEvent.AuditEventAgentNetworkComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAuditEventAuditEventAgentNetworkComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAuditEventAuditEventAgentNetworkComponentContent(int eventType, XmlPullParser xpp, AuditEvent owner, AuditEvent.AuditEventAgentNetworkComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("address")) {
- res.setAddressElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, AuditEvent.AuditEventParticipantNetworkType.NULL, new AuditEvent.AuditEventParticipantNetworkTypeEnumFactory()));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected AuditEvent.AuditEventSourceComponent parseAuditEventAuditEventSourceComponent(XmlPullParser xpp, AuditEvent owner) throws XmlPullParserException, IOException, FHIRFormatError {
- AuditEvent.AuditEventSourceComponent res = new AuditEvent.AuditEventSourceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAuditEventAuditEventSourceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAuditEventAuditEventSourceComponentContent(int eventType, XmlPullParser xpp, AuditEvent owner, AuditEvent.AuditEventSourceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("site")) {
- res.setSiteElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected AuditEvent.AuditEventEntityComponent parseAuditEventAuditEventEntityComponent(XmlPullParser xpp, AuditEvent owner) throws XmlPullParserException, IOException, FHIRFormatError {
- AuditEvent.AuditEventEntityComponent res = new AuditEvent.AuditEventEntityComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAuditEventAuditEventEntityComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAuditEventAuditEventEntityComponentContent(int eventType, XmlPullParser xpp, AuditEvent owner, AuditEvent.AuditEventEntityComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reference")) {
- res.setReference(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.setRole(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lifecycle")) {
- res.setLifecycle(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("securityLabel")) {
- res.getSecurityLabel().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("query")) {
- res.setQueryElement(parseBase64Binary(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.getDetail().add(parseAuditEventAuditEventEntityDetailComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected AuditEvent.AuditEventEntityDetailComponent parseAuditEventAuditEventEntityDetailComponent(XmlPullParser xpp, AuditEvent owner) throws XmlPullParserException, IOException, FHIRFormatError {
- AuditEvent.AuditEventEntityDetailComponent res = new AuditEvent.AuditEventEntityDetailComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseAuditEventAuditEventEntityDetailComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseAuditEventAuditEventEntityDetailComponentContent(int eventType, XmlPullParser xpp, AuditEvent owner, AuditEvent.AuditEventEntityDetailComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseBase64Binary(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Basic parseBasic(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Basic res = new Basic();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseBasicContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseBasicContent(int eventType, XmlPullParser xpp, Basic res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.setAuthor(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Binary parseBinary(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Binary res = new Binary();
- parseResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseBinaryContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseBinaryContent(int eventType, XmlPullParser xpp, Binary res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contentType")) {
- res.setContentTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("content")) {
- res.setContentElement(parseBase64Binary(xpp));
- } else if (!parseResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected BodySite parseBodySite(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- BodySite res = new BodySite();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseBodySiteContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseBodySiteContent(int eventType, XmlPullParser xpp, BodySite res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("modifier")) {
- res.getModifier().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("image")) {
- res.getImage().add(parseAttachment(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Bundle parseBundle(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Bundle res = new Bundle();
- parseResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseBundleContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseBundleContent(int eventType, XmlPullParser xpp, Bundle res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Bundle.BundleType.NULL, new Bundle.BundleTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("total")) {
- res.setTotalElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("link")) {
- res.getLink().add(parseBundleBundleLinkComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("entry")) {
- res.getEntry().add(parseBundleBundleEntryComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("signature")) {
- res.setSignature(parseSignature(xpp));
- } else if (!parseResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Bundle.BundleLinkComponent parseBundleBundleLinkComponent(XmlPullParser xpp, Bundle owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Bundle.BundleLinkComponent res = new Bundle.BundleLinkComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseBundleBundleLinkComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseBundleBundleLinkComponentContent(int eventType, XmlPullParser xpp, Bundle owner, Bundle.BundleLinkComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relation")) {
- res.setRelationElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Bundle.BundleEntryComponent parseBundleBundleEntryComponent(XmlPullParser xpp, Bundle owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Bundle.BundleEntryComponent res = new Bundle.BundleEntryComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseBundleBundleEntryComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseBundleBundleEntryComponentContent(int eventType, XmlPullParser xpp, Bundle owner, Bundle.BundleEntryComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("link")) {
- res.getLink().add(parseBundleBundleLinkComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fullUrl")) {
- res.setFullUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.setResource(parseResourceContained(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("search")) {
- res.setSearch(parseBundleBundleEntrySearchComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("request")) {
- res.setRequest(parseBundleBundleEntryRequestComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("response")) {
- res.setResponse(parseBundleBundleEntryResponseComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Bundle.BundleEntrySearchComponent parseBundleBundleEntrySearchComponent(XmlPullParser xpp, Bundle owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Bundle.BundleEntrySearchComponent res = new Bundle.BundleEntrySearchComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseBundleBundleEntrySearchComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseBundleBundleEntrySearchComponentContent(int eventType, XmlPullParser xpp, Bundle owner, Bundle.BundleEntrySearchComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mode")) {
- res.setModeElement(parseEnumeration(xpp, Bundle.SearchEntryMode.NULL, new Bundle.SearchEntryModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("score")) {
- res.setScoreElement(parseDecimal(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Bundle.BundleEntryRequestComponent parseBundleBundleEntryRequestComponent(XmlPullParser xpp, Bundle owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Bundle.BundleEntryRequestComponent res = new Bundle.BundleEntryRequestComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseBundleBundleEntryRequestComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseBundleBundleEntryRequestComponentContent(int eventType, XmlPullParser xpp, Bundle owner, Bundle.BundleEntryRequestComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("method")) {
- res.setMethodElement(parseEnumeration(xpp, Bundle.HTTPVerb.NULL, new Bundle.HTTPVerbEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ifNoneMatch")) {
- res.setIfNoneMatchElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ifModifiedSince")) {
- res.setIfModifiedSinceElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ifMatch")) {
- res.setIfMatchElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ifNoneExist")) {
- res.setIfNoneExistElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Bundle.BundleEntryResponseComponent parseBundleBundleEntryResponseComponent(XmlPullParser xpp, Bundle owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Bundle.BundleEntryResponseComponent res = new Bundle.BundleEntryResponseComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseBundleBundleEntryResponseComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseBundleBundleEntryResponseComponentContent(int eventType, XmlPullParser xpp, Bundle owner, Bundle.BundleEntryResponseComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.setLocationElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("etag")) {
- res.setEtagElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lastModified")) {
- res.setLastModifiedElement(parseInstant(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CarePlan parseCarePlan(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- CarePlan res = new CarePlan();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCarePlanContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCarePlanContent(int eventType, XmlPullParser xpp, CarePlan res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, CarePlan.CarePlanStatus.NULL, new CarePlan.CarePlanStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("context")) {
- res.setContext(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.getAuthor().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("modified")) {
- res.setModifiedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.getCategory().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("addresses")) {
- res.getAddresses().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("support")) {
- res.getSupport().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relatedPlan")) {
- res.getRelatedPlan().add(parseCarePlanCarePlanRelatedPlanComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("careTeam")) {
- res.setCareTeam(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("goal")) {
- res.getGoal().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("activity")) {
- res.getActivity().add(parseCarePlanCarePlanActivityComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.setNote(parseAnnotation(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CarePlan.CarePlanRelatedPlanComponent parseCarePlanCarePlanRelatedPlanComponent(XmlPullParser xpp, CarePlan owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CarePlan.CarePlanRelatedPlanComponent res = new CarePlan.CarePlanRelatedPlanComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCarePlanCarePlanRelatedPlanComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCarePlanCarePlanRelatedPlanComponentContent(int eventType, XmlPullParser xpp, CarePlan owner, CarePlan.CarePlanRelatedPlanComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseEnumeration(xpp, CarePlan.CarePlanRelationship.NULL, new CarePlan.CarePlanRelationshipEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("plan")) {
- res.setPlan(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CarePlan.CarePlanActivityComponent parseCarePlanCarePlanActivityComponent(XmlPullParser xpp, CarePlan owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CarePlan.CarePlanActivityComponent res = new CarePlan.CarePlanActivityComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCarePlanCarePlanActivityComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCarePlanCarePlanActivityComponentContent(int eventType, XmlPullParser xpp, CarePlan owner, CarePlan.CarePlanActivityComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actionResulting")) {
- res.getActionResulting().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("progress")) {
- res.getProgress().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reference")) {
- res.setReference(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.setDetail(parseCarePlanCarePlanActivityDetailComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CarePlan.CarePlanActivityDetailComponent parseCarePlanCarePlanActivityDetailComponent(XmlPullParser xpp, CarePlan owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CarePlan.CarePlanActivityDetailComponent res = new CarePlan.CarePlanActivityDetailComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCarePlanCarePlanActivityDetailComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCarePlanCarePlanActivityDetailComponentContent(int eventType, XmlPullParser xpp, CarePlan owner, CarePlan.CarePlanActivityDetailComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reasonCode")) {
- res.getReasonCode().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reasonReference")) {
- res.getReasonReference().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("goal")) {
- res.getGoal().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, CarePlan.CarePlanActivityStatus.NULL, new CarePlan.CarePlanActivityStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("statusReason")) {
- res.setStatusReason(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prohibited")) {
- res.setProhibitedElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "scheduled")) {
- res.setScheduled(parseType("scheduled", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.setLocation(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("performer")) {
- res.getPerformer().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "product")) {
- res.setProduct(parseType("product", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dailyAmount")) {
- res.setDailyAmount(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CareTeam parseCareTeam(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- CareTeam res = new CareTeam();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCareTeamContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCareTeamContent(int eventType, XmlPullParser xpp, CareTeam res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatus(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("participant")) {
- res.getParticipant().add(parseCareTeamCareTeamParticipantComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("managingOrganization")) {
- res.setManagingOrganization(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CareTeam.CareTeamParticipantComponent parseCareTeamCareTeamParticipantComponent(XmlPullParser xpp, CareTeam owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CareTeam.CareTeamParticipantComponent res = new CareTeam.CareTeamParticipantComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCareTeamCareTeamParticipantComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCareTeamCareTeamParticipantComponentContent(int eventType, XmlPullParser xpp, CareTeam owner, CareTeam.CareTeamParticipantComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.setRole(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("member")) {
- res.setMember(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim parseClaim(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim res = new Claim();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimContent(int eventType, XmlPullParser xpp, Claim res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Claim.ClaimType.NULL, new Claim.ClaimTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subType")) {
- res.getSubType().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("billablePeriod")) {
- res.setBillablePeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "target")) {
- res.setTarget(parseType("target", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "provider")) {
- res.setProvider(parseType("provider", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "organization")) {
- res.setOrganization(parseType("organization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUseElement(parseEnumeration(xpp, Claim.Use.NULL, new Claim.UseEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priority")) {
- res.setPriority(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fundsReserve")) {
- res.setFundsReserve(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "enterer")) {
- res.setEnterer(parseType("enterer", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "facility")) {
- res.setFacility(parseType("facility", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("related")) {
- res.getRelated().add(parseClaimRelatedClaimComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "prescription")) {
- res.setPrescription(parseType("prescription", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "originalPrescription")) {
- res.setOriginalPrescription(parseType("originalPrescription", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("payee")) {
- res.setPayee(parseClaimPayeeComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "referral")) {
- res.setReferral(parseType("referral", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("information")) {
- res.getInformation().add(parseClaimInformationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("diagnosis")) {
- res.getDiagnosis().add(parseClaimDiagnosisComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("procedure")) {
- res.getProcedure().add(parseClaimProcedureComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "patient")) {
- res.setPatient(parseType("patient", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("coverage")) {
- res.getCoverage().add(parseClaimCoverageComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseClaimItemComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("total")) {
- res.setTotal(parseMoney(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim.RelatedClaimComponent parseClaimRelatedClaimComponent(XmlPullParser xpp, Claim owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim.RelatedClaimComponent res = new Claim.RelatedClaimComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimRelatedClaimComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimRelatedClaimComponentContent(int eventType, XmlPullParser xpp, Claim owner, Claim.RelatedClaimComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "claim")) {
- res.setClaim(parseType("claim", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relationship")) {
- res.setRelationship(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reference")) {
- res.setReference(parseIdentifier(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim.PayeeComponent parseClaimPayeeComponent(XmlPullParser xpp, Claim owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim.PayeeComponent res = new Claim.PayeeComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimPayeeComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimPayeeComponentContent(int eventType, XmlPullParser xpp, Claim owner, Claim.PayeeComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resourceType")) {
- res.setResourceType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "party")) {
- res.setParty(parseType("party", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim.InformationComponent parseClaimInformationComponent(XmlPullParser xpp, Claim owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim.InformationComponent res = new Claim.InformationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimInformationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimInformationComponentContent(int eventType, XmlPullParser xpp, Claim owner, Claim.InformationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "timing")) {
- res.setTiming(parseType("timing", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim.DiagnosisComponent parseClaimDiagnosisComponent(XmlPullParser xpp, Claim owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim.DiagnosisComponent res = new Claim.DiagnosisComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimDiagnosisComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimDiagnosisComponentContent(int eventType, XmlPullParser xpp, Claim owner, Claim.DiagnosisComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("diagnosis")) {
- res.setDiagnosis(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim.ProcedureComponent parseClaimProcedureComponent(XmlPullParser xpp, Claim owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim.ProcedureComponent res = new Claim.ProcedureComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimProcedureComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimProcedureComponentContent(int eventType, XmlPullParser xpp, Claim owner, Claim.ProcedureComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "procedure")) {
- res.setProcedure(parseType("procedure", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim.CoverageComponent parseClaimCoverageComponent(XmlPullParser xpp, Claim owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim.CoverageComponent res = new Claim.CoverageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimCoverageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimCoverageComponentContent(int eventType, XmlPullParser xpp, Claim owner, Claim.CoverageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("focal")) {
- res.setFocalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "coverage")) {
- res.setCoverage(parseType("coverage", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("preAuthRef")) {
- res.getPreAuthRef().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("claimResponse")) {
- res.setClaimResponse(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim.ItemComponent parseClaimItemComponent(XmlPullParser xpp, Claim owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim.ItemComponent res = new Claim.ItemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimItemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimItemComponentContent(int eventType, XmlPullParser xpp, Claim owner, Claim.ItemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("careTeam")) {
- res.getCareTeam().add(parseClaimCareTeamComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("diagnosisLinkId")) {
- res.getDiagnosisLinkId().add(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("service")) {
- res.setService(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceModifier")) {
- res.getServiceModifier().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("modifier")) {
- res.getModifier().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("programCode")) {
- res.getProgramCode().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "serviced")) {
- res.setServiced(parseType("serviced", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "serviceLocation")) {
- res.setServiceLocation(parseType("serviceLocation", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unitPrice")) {
- res.setUnitPrice(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("factor")) {
- res.setFactorElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("points")) {
- res.setPointsElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("net")) {
- res.setNet(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("udi")) {
- res.getUdi().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("bodySite")) {
- res.setBodySite(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subSite")) {
- res.getSubSite().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.getDetail().add(parseClaimDetailComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prosthesis")) {
- res.setProsthesis(parseClaimProsthesisComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim.CareTeamComponent parseClaimCareTeamComponent(XmlPullParser xpp, Claim owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim.CareTeamComponent res = new Claim.CareTeamComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimCareTeamComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimCareTeamComponentContent(int eventType, XmlPullParser xpp, Claim owner, Claim.CareTeamComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "provider")) {
- res.setProvider(parseType("provider", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("responsible")) {
- res.setResponsibleElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.setRole(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("qualification")) {
- res.setQualification(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim.DetailComponent parseClaimDetailComponent(XmlPullParser xpp, Claim owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim.DetailComponent res = new Claim.DetailComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimDetailComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimDetailComponentContent(int eventType, XmlPullParser xpp, Claim owner, Claim.DetailComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("service")) {
- res.setService(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("programCode")) {
- res.getProgramCode().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unitPrice")) {
- res.setUnitPrice(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("factor")) {
- res.setFactorElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("points")) {
- res.setPointsElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("net")) {
- res.setNet(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("udi")) {
- res.getUdi().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subDetail")) {
- res.getSubDetail().add(parseClaimSubDetailComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim.SubDetailComponent parseClaimSubDetailComponent(XmlPullParser xpp, Claim owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim.SubDetailComponent res = new Claim.SubDetailComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimSubDetailComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimSubDetailComponentContent(int eventType, XmlPullParser xpp, Claim owner, Claim.SubDetailComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("service")) {
- res.setService(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("programCode")) {
- res.getProgramCode().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unitPrice")) {
- res.setUnitPrice(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("factor")) {
- res.setFactorElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("points")) {
- res.setPointsElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("net")) {
- res.setNet(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("udi")) {
- res.getUdi().add(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Claim.ProsthesisComponent parseClaimProsthesisComponent(XmlPullParser xpp, Claim owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Claim.ProsthesisComponent res = new Claim.ProsthesisComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimProsthesisComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimProsthesisComponentContent(int eventType, XmlPullParser xpp, Claim owner, Claim.ProsthesisComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("initial")) {
- res.setInitialElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priorDate")) {
- res.setPriorDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priorMaterial")) {
- res.setPriorMaterial(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClaimResponse parseClaimResponse(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ClaimResponse res = new ClaimResponse();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimResponseContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimResponseContent(int eventType, XmlPullParser xpp, ClaimResponse res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "request")) {
- res.setRequest(parseType("request", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "organization")) {
- res.setOrganization(parseType("organization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "requestProvider")) {
- res.setRequestProvider(parseType("requestProvider", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "requestOrganization")) {
- res.setRequestOrganization(parseType("requestOrganization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outcome")) {
- res.setOutcomeElement(parseEnumeration(xpp, Enumerations.RemittanceOutcome.NULL, new Enumerations.RemittanceOutcomeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("disposition")) {
- res.setDispositionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("payeeType")) {
- res.setPayeeType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseClaimResponseItemComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("addItem")) {
- res.getAddItem().add(parseClaimResponseAddedItemComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("error")) {
- res.getError().add(parseClaimResponseErrorComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("totalCost")) {
- res.setTotalCost(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unallocDeductable")) {
- res.setUnallocDeductable(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("totalBenefit")) {
- res.setTotalBenefit(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("paymentAdjustment")) {
- res.setPaymentAdjustment(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("paymentAdjustmentReason")) {
- res.setPaymentAdjustmentReason(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("paymentDate")) {
- res.setPaymentDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("paymentAmount")) {
- res.setPaymentAmount(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("paymentRef")) {
- res.setPaymentRef(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reserved")) {
- res.setReserved(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("form")) {
- res.setForm(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseClaimResponseNoteComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("coverage")) {
- res.getCoverage().add(parseClaimResponseCoverageComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClaimResponse.ItemComponent parseClaimResponseItemComponent(XmlPullParser xpp, ClaimResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClaimResponse.ItemComponent res = new ClaimResponse.ItemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimResponseItemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimResponseItemComponentContent(int eventType, XmlPullParser xpp, ClaimResponse owner, ClaimResponse.ItemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequenceLinkId")) {
- res.setSequenceLinkIdElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("noteNumber")) {
- res.getNoteNumber().add(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("adjudication")) {
- res.getAdjudication().add(parseClaimResponseAdjudicationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.getDetail().add(parseClaimResponseItemDetailComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClaimResponse.AdjudicationComponent parseClaimResponseAdjudicationComponent(XmlPullParser xpp, ClaimResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClaimResponse.AdjudicationComponent res = new ClaimResponse.AdjudicationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimResponseAdjudicationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimResponseAdjudicationComponentContent(int eventType, XmlPullParser xpp, ClaimResponse owner, ClaimResponse.AdjudicationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("amount")) {
- res.setAmount(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseDecimal(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClaimResponse.ItemDetailComponent parseClaimResponseItemDetailComponent(XmlPullParser xpp, ClaimResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClaimResponse.ItemDetailComponent res = new ClaimResponse.ItemDetailComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimResponseItemDetailComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimResponseItemDetailComponentContent(int eventType, XmlPullParser xpp, ClaimResponse owner, ClaimResponse.ItemDetailComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequenceLinkId")) {
- res.setSequenceLinkIdElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("adjudication")) {
- res.getAdjudication().add(parseClaimResponseAdjudicationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subDetail")) {
- res.getSubDetail().add(parseClaimResponseSubDetailComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClaimResponse.SubDetailComponent parseClaimResponseSubDetailComponent(XmlPullParser xpp, ClaimResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClaimResponse.SubDetailComponent res = new ClaimResponse.SubDetailComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimResponseSubDetailComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimResponseSubDetailComponentContent(int eventType, XmlPullParser xpp, ClaimResponse owner, ClaimResponse.SubDetailComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequenceLinkId")) {
- res.setSequenceLinkIdElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("adjudication")) {
- res.getAdjudication().add(parseClaimResponseAdjudicationComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClaimResponse.AddedItemComponent parseClaimResponseAddedItemComponent(XmlPullParser xpp, ClaimResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClaimResponse.AddedItemComponent res = new ClaimResponse.AddedItemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimResponseAddedItemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimResponseAddedItemComponentContent(int eventType, XmlPullParser xpp, ClaimResponse owner, ClaimResponse.AddedItemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequenceLinkId")) {
- res.getSequenceLinkId().add(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("service")) {
- res.setService(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fee")) {
- res.setFee(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("noteNumberLinkId")) {
- res.getNoteNumberLinkId().add(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("adjudication")) {
- res.getAdjudication().add(parseClaimResponseAdjudicationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.getDetail().add(parseClaimResponseAddedItemsDetailComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClaimResponse.AddedItemsDetailComponent parseClaimResponseAddedItemsDetailComponent(XmlPullParser xpp, ClaimResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClaimResponse.AddedItemsDetailComponent res = new ClaimResponse.AddedItemsDetailComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimResponseAddedItemsDetailComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimResponseAddedItemsDetailComponentContent(int eventType, XmlPullParser xpp, ClaimResponse owner, ClaimResponse.AddedItemsDetailComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("service")) {
- res.setService(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fee")) {
- res.setFee(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("adjudication")) {
- res.getAdjudication().add(parseClaimResponseAdjudicationComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClaimResponse.ErrorComponent parseClaimResponseErrorComponent(XmlPullParser xpp, ClaimResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClaimResponse.ErrorComponent res = new ClaimResponse.ErrorComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimResponseErrorComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimResponseErrorComponentContent(int eventType, XmlPullParser xpp, ClaimResponse owner, ClaimResponse.ErrorComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequenceLinkId")) {
- res.setSequenceLinkIdElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detailSequenceLinkId")) {
- res.setDetailSequenceLinkIdElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subdetailSequenceLinkId")) {
- res.setSubdetailSequenceLinkIdElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClaimResponse.NoteComponent parseClaimResponseNoteComponent(XmlPullParser xpp, ClaimResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClaimResponse.NoteComponent res = new ClaimResponse.NoteComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimResponseNoteComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimResponseNoteComponentContent(int eventType, XmlPullParser xpp, ClaimResponse owner, ClaimResponse.NoteComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("number")) {
- res.setNumberElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClaimResponse.CoverageComponent parseClaimResponseCoverageComponent(XmlPullParser xpp, ClaimResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClaimResponse.CoverageComponent res = new ClaimResponse.CoverageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClaimResponseCoverageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClaimResponseCoverageComponentContent(int eventType, XmlPullParser xpp, ClaimResponse owner, ClaimResponse.CoverageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("focal")) {
- res.setFocalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "coverage")) {
- res.setCoverage(parseType("coverage", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("businessArrangement")) {
- res.setBusinessArrangementElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("preAuthRef")) {
- res.getPreAuthRef().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("claimResponse")) {
- res.setClaimResponse(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClinicalImpression parseClinicalImpression(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ClinicalImpression res = new ClinicalImpression();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClinicalImpressionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClinicalImpressionContent(int eventType, XmlPullParser xpp, ClinicalImpression res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("assessor")) {
- res.setAssessor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, ClinicalImpression.ClinicalImpressionStatus.NULL, new ClinicalImpression.ClinicalImpressionStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("previous")) {
- res.setPrevious(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("problem")) {
- res.getProblem().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "trigger")) {
- res.setTrigger(parseType("trigger", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("investigations")) {
- res.getInvestigations().add(parseClinicalImpressionClinicalImpressionInvestigationsComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("protocol")) {
- res.setProtocolElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("summary")) {
- res.setSummaryElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("finding")) {
- res.getFinding().add(parseClinicalImpressionClinicalImpressionFindingComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resolved")) {
- res.getResolved().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruledOut")) {
- res.getRuledOut().add(parseClinicalImpressionClinicalImpressionRuledOutComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prognosis")) {
- res.setPrognosisElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("plan")) {
- res.getPlan().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClinicalImpression.ClinicalImpressionInvestigationsComponent parseClinicalImpressionClinicalImpressionInvestigationsComponent(XmlPullParser xpp, ClinicalImpression owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClinicalImpression.ClinicalImpressionInvestigationsComponent res = new ClinicalImpression.ClinicalImpressionInvestigationsComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClinicalImpressionClinicalImpressionInvestigationsComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClinicalImpressionClinicalImpressionInvestigationsComponentContent(int eventType, XmlPullParser xpp, ClinicalImpression owner, ClinicalImpression.ClinicalImpressionInvestigationsComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClinicalImpression.ClinicalImpressionFindingComponent parseClinicalImpressionClinicalImpressionFindingComponent(XmlPullParser xpp, ClinicalImpression owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClinicalImpression.ClinicalImpressionFindingComponent res = new ClinicalImpression.ClinicalImpressionFindingComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClinicalImpressionClinicalImpressionFindingComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClinicalImpressionClinicalImpressionFindingComponentContent(int eventType, XmlPullParser xpp, ClinicalImpression owner, ClinicalImpression.ClinicalImpressionFindingComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.setItem(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("cause")) {
- res.setCauseElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ClinicalImpression.ClinicalImpressionRuledOutComponent parseClinicalImpressionClinicalImpressionRuledOutComponent(XmlPullParser xpp, ClinicalImpression owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ClinicalImpression.ClinicalImpressionRuledOutComponent res = new ClinicalImpression.ClinicalImpressionRuledOutComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseClinicalImpressionClinicalImpressionRuledOutComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseClinicalImpressionClinicalImpressionRuledOutComponentContent(int eventType, XmlPullParser xpp, ClinicalImpression owner, ClinicalImpression.ClinicalImpressionRuledOutComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.setItem(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReasonElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CodeSystem parseCodeSystem(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- CodeSystem res = new CodeSystem();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCodeSystemContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCodeSystemContent(int eventType, XmlPullParser xpp, CodeSystem res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseCodeSystemCodeSystemContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("copyright")) {
- res.setCopyrightElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("caseSensitive")) {
- res.setCaseSensitiveElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("valueSet")) {
- res.setValueSetElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("compositional")) {
- res.setCompositionalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("versionNeeded")) {
- res.setVersionNeededElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("content")) {
- res.setContentElement(parseEnumeration(xpp, CodeSystem.CodeSystemContentMode.NULL, new CodeSystem.CodeSystemContentModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("count")) {
- res.setCountElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("filter")) {
- res.getFilter().add(parseCodeSystemCodeSystemFilterComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("property")) {
- res.getProperty().add(parseCodeSystemCodeSystemPropertyComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("concept")) {
- res.getConcept().add(parseCodeSystemConceptDefinitionComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CodeSystem.CodeSystemContactComponent parseCodeSystemCodeSystemContactComponent(XmlPullParser xpp, CodeSystem owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CodeSystem.CodeSystemContactComponent res = new CodeSystem.CodeSystemContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCodeSystemCodeSystemContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCodeSystemCodeSystemContactComponentContent(int eventType, XmlPullParser xpp, CodeSystem owner, CodeSystem.CodeSystemContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CodeSystem.CodeSystemFilterComponent parseCodeSystemCodeSystemFilterComponent(XmlPullParser xpp, CodeSystem owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CodeSystem.CodeSystemFilterComponent res = new CodeSystem.CodeSystemFilterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCodeSystemCodeSystemFilterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCodeSystemCodeSystemFilterComponentContent(int eventType, XmlPullParser xpp, CodeSystem owner, CodeSystem.CodeSystemFilterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("operator")) {
- res.getOperator().add(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CodeSystem.CodeSystemPropertyComponent parseCodeSystemCodeSystemPropertyComponent(XmlPullParser xpp, CodeSystem owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CodeSystem.CodeSystemPropertyComponent res = new CodeSystem.CodeSystemPropertyComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCodeSystemCodeSystemPropertyComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCodeSystemCodeSystemPropertyComponentContent(int eventType, XmlPullParser xpp, CodeSystem owner, CodeSystem.CodeSystemPropertyComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("uri")) {
- res.setUriElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, CodeSystem.PropertyType.NULL, new CodeSystem.PropertyTypeEnumFactory()));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CodeSystem.ConceptDefinitionComponent parseCodeSystemConceptDefinitionComponent(XmlPullParser xpp, CodeSystem owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CodeSystem.ConceptDefinitionComponent res = new CodeSystem.ConceptDefinitionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCodeSystemConceptDefinitionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCodeSystemConceptDefinitionComponentContent(int eventType, XmlPullParser xpp, CodeSystem owner, CodeSystem.ConceptDefinitionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("display")) {
- res.setDisplayElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("definition")) {
- res.setDefinitionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("designation")) {
- res.getDesignation().add(parseCodeSystemConceptDefinitionDesignationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("property")) {
- res.getProperty().add(parseCodeSystemConceptDefinitionPropertyComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("concept")) {
- res.getConcept().add(parseCodeSystemConceptDefinitionComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CodeSystem.ConceptDefinitionDesignationComponent parseCodeSystemConceptDefinitionDesignationComponent(XmlPullParser xpp, CodeSystem owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CodeSystem.ConceptDefinitionDesignationComponent res = new CodeSystem.ConceptDefinitionDesignationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCodeSystemConceptDefinitionDesignationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCodeSystemConceptDefinitionDesignationComponentContent(int eventType, XmlPullParser xpp, CodeSystem owner, CodeSystem.ConceptDefinitionDesignationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("language")) {
- res.setLanguageElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUse(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CodeSystem.ConceptDefinitionPropertyComponent parseCodeSystemConceptDefinitionPropertyComponent(XmlPullParser xpp, CodeSystem owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CodeSystem.ConceptDefinitionPropertyComponent res = new CodeSystem.ConceptDefinitionPropertyComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCodeSystemConceptDefinitionPropertyComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCodeSystemConceptDefinitionPropertyComponentContent(int eventType, XmlPullParser xpp, CodeSystem owner, CodeSystem.ConceptDefinitionPropertyComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Communication parseCommunication(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Communication res = new Communication();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCommunicationContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCommunicationContent(int eventType, XmlPullParser xpp, Communication res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sender")) {
- res.setSender(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recipient")) {
- res.getRecipient().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("payload")) {
- res.getPayload().add(parseCommunicationCommunicationPayloadComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("medium")) {
- res.getMedium().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Communication.CommunicationStatus.NULL, new Communication.CommunicationStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sent")) {
- res.setSentElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("received")) {
- res.setReceivedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.getReason().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requestDetail")) {
- res.setRequestDetail(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Communication.CommunicationPayloadComponent parseCommunicationCommunicationPayloadComponent(XmlPullParser xpp, Communication owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Communication.CommunicationPayloadComponent res = new Communication.CommunicationPayloadComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCommunicationCommunicationPayloadComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCommunicationCommunicationPayloadComponentContent(int eventType, XmlPullParser xpp, Communication owner, Communication.CommunicationPayloadComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "content")) {
- res.setContent(parseType("content", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CommunicationRequest parseCommunicationRequest(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- CommunicationRequest res = new CommunicationRequest();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCommunicationRequestContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCommunicationRequestContent(int eventType, XmlPullParser xpp, CommunicationRequest res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sender")) {
- res.setSender(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recipient")) {
- res.getRecipient().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("payload")) {
- res.getPayload().add(parseCommunicationRequestCommunicationRequestPayloadComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("medium")) {
- res.getMedium().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requester")) {
- res.setRequester(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, CommunicationRequest.CommunicationRequestStatus.NULL, new CommunicationRequest.CommunicationRequestStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "scheduled")) {
- res.setScheduled(parseType("scheduled", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.getReason().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requestedOn")) {
- res.setRequestedOnElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priority")) {
- res.setPriority(parseCodeableConcept(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CommunicationRequest.CommunicationRequestPayloadComponent parseCommunicationRequestCommunicationRequestPayloadComponent(XmlPullParser xpp, CommunicationRequest owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CommunicationRequest.CommunicationRequestPayloadComponent res = new CommunicationRequest.CommunicationRequestPayloadComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCommunicationRequestCommunicationRequestPayloadComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCommunicationRequestCommunicationRequestPayloadComponentContent(int eventType, XmlPullParser xpp, CommunicationRequest owner, CommunicationRequest.CommunicationRequestPayloadComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "content")) {
- res.setContent(parseType("content", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CompartmentDefinition parseCompartmentDefinition(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- CompartmentDefinition res = new CompartmentDefinition();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCompartmentDefinitionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCompartmentDefinitionContent(int eventType, XmlPullParser xpp, CompartmentDefinition res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseCompartmentDefinitionCompartmentDefinitionContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseEnumeration(xpp, CompartmentDefinition.CompartmentType.NULL, new CompartmentDefinition.CompartmentTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("search")) {
- res.setSearchElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.getResource().add(parseCompartmentDefinitionCompartmentDefinitionResourceComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CompartmentDefinition.CompartmentDefinitionContactComponent parseCompartmentDefinitionCompartmentDefinitionContactComponent(XmlPullParser xpp, CompartmentDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CompartmentDefinition.CompartmentDefinitionContactComponent res = new CompartmentDefinition.CompartmentDefinitionContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCompartmentDefinitionCompartmentDefinitionContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCompartmentDefinitionCompartmentDefinitionContactComponentContent(int eventType, XmlPullParser xpp, CompartmentDefinition owner, CompartmentDefinition.CompartmentDefinitionContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected CompartmentDefinition.CompartmentDefinitionResourceComponent parseCompartmentDefinitionCompartmentDefinitionResourceComponent(XmlPullParser xpp, CompartmentDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- CompartmentDefinition.CompartmentDefinitionResourceComponent res = new CompartmentDefinition.CompartmentDefinitionResourceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCompartmentDefinitionCompartmentDefinitionResourceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCompartmentDefinitionCompartmentDefinitionResourceComponentContent(int eventType, XmlPullParser xpp, CompartmentDefinition owner, CompartmentDefinition.CompartmentDefinitionResourceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("param")) {
- res.getParam().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Composition parseComposition(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Composition res = new Composition();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCompositionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCompositionContent(int eventType, XmlPullParser xpp, Composition res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("class")) {
- res.setClass_(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("title")) {
- res.setTitleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Composition.CompositionStatus.NULL, new Composition.CompositionStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("confidentiality")) {
- res.setConfidentialityElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.getAuthor().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("attester")) {
- res.getAttester().add(parseCompositionCompositionAttesterComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("custodian")) {
- res.setCustodian(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("event")) {
- res.getEvent().add(parseCompositionCompositionEventComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("section")) {
- res.getSection().add(parseCompositionSectionComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Composition.CompositionAttesterComponent parseCompositionCompositionAttesterComponent(XmlPullParser xpp, Composition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Composition.CompositionAttesterComponent res = new Composition.CompositionAttesterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCompositionCompositionAttesterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCompositionCompositionAttesterComponentContent(int eventType, XmlPullParser xpp, Composition owner, Composition.CompositionAttesterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mode")) {
- res.getMode().add(parseEnumeration(xpp, Composition.CompositionAttestationMode.NULL, new Composition.CompositionAttestationModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("time")) {
- res.setTimeElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("party")) {
- res.setParty(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Composition.CompositionEventComponent parseCompositionCompositionEventComponent(XmlPullParser xpp, Composition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Composition.CompositionEventComponent res = new Composition.CompositionEventComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCompositionCompositionEventComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCompositionCompositionEventComponentContent(int eventType, XmlPullParser xpp, Composition owner, Composition.CompositionEventComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.getCode().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.getDetail().add(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Composition.SectionComponent parseCompositionSectionComponent(XmlPullParser xpp, Composition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Composition.SectionComponent res = new Composition.SectionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCompositionSectionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCompositionSectionComponentContent(int eventType, XmlPullParser xpp, Composition owner, Composition.SectionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("title")) {
- res.setTitleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setText(parseNarrative(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mode")) {
- res.setModeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("orderedBy")) {
- res.setOrderedBy(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("entry")) {
- res.getEntry().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("emptyReason")) {
- res.setEmptyReason(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("section")) {
- res.getSection().add(parseCompositionSectionComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ConceptMap parseConceptMap(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ConceptMap res = new ConceptMap();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConceptMapContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConceptMapContent(int eventType, XmlPullParser xpp, ConceptMap res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseConceptMapConceptMapContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("copyright")) {
- res.setCopyrightElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "source")) {
- res.setSource(parseType("source", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "target")) {
- res.setTarget(parseType("target", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("element")) {
- res.getElement().add(parseConceptMapSourceElementComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ConceptMap.ConceptMapContactComponent parseConceptMapConceptMapContactComponent(XmlPullParser xpp, ConceptMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ConceptMap.ConceptMapContactComponent res = new ConceptMap.ConceptMapContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConceptMapConceptMapContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConceptMapConceptMapContactComponentContent(int eventType, XmlPullParser xpp, ConceptMap owner, ConceptMap.ConceptMapContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ConceptMap.SourceElementComponent parseConceptMapSourceElementComponent(XmlPullParser xpp, ConceptMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ConceptMap.SourceElementComponent res = new ConceptMap.SourceElementComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConceptMapSourceElementComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConceptMapSourceElementComponentContent(int eventType, XmlPullParser xpp, ConceptMap owner, ConceptMap.SourceElementComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.getTarget().add(parseConceptMapTargetElementComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ConceptMap.TargetElementComponent parseConceptMapTargetElementComponent(XmlPullParser xpp, ConceptMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ConceptMap.TargetElementComponent res = new ConceptMap.TargetElementComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConceptMapTargetElementComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConceptMapTargetElementComponentContent(int eventType, XmlPullParser xpp, ConceptMap owner, ConceptMap.TargetElementComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("equivalence")) {
- res.setEquivalenceElement(parseEnumeration(xpp, Enumerations.ConceptMapEquivalence.NULL, new Enumerations.ConceptMapEquivalenceEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comments")) {
- res.setCommentsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dependsOn")) {
- res.getDependsOn().add(parseConceptMapOtherElementComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("product")) {
- res.getProduct().add(parseConceptMapOtherElementComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ConceptMap.OtherElementComponent parseConceptMapOtherElementComponent(XmlPullParser xpp, ConceptMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ConceptMap.OtherElementComponent res = new ConceptMap.OtherElementComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConceptMapOtherElementComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConceptMapOtherElementComponentContent(int eventType, XmlPullParser xpp, ConceptMap owner, ConceptMap.OtherElementComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("element")) {
- res.setElementElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Condition parseCondition(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Condition res = new Condition();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConditionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConditionContent(int eventType, XmlPullParser xpp, Condition res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("asserter")) {
- res.setAsserter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateRecorded")) {
- res.setDateRecordedElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("clinicalStatus")) {
- res.setClinicalStatusElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("verificationStatus")) {
- res.setVerificationStatusElement(parseEnumeration(xpp, Condition.ConditionVerificationStatus.NULL, new Condition.ConditionVerificationStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("severity")) {
- res.setSeverity(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "onset")) {
- res.setOnset(parseType("onset", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "abatement")) {
- res.setAbatement(parseType("abatement", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("stage")) {
- res.setStage(parseConditionConditionStageComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("evidence")) {
- res.getEvidence().add(parseConditionConditionEvidenceComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("bodySite")) {
- res.getBodySite().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Condition.ConditionStageComponent parseConditionConditionStageComponent(XmlPullParser xpp, Condition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Condition.ConditionStageComponent res = new Condition.ConditionStageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConditionConditionStageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConditionConditionStageComponentContent(int eventType, XmlPullParser xpp, Condition owner, Condition.ConditionStageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("summary")) {
- res.setSummary(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("assessment")) {
- res.getAssessment().add(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Condition.ConditionEvidenceComponent parseConditionConditionEvidenceComponent(XmlPullParser xpp, Condition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Condition.ConditionEvidenceComponent res = new Condition.ConditionEvidenceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConditionConditionEvidenceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConditionConditionEvidenceComponentContent(int eventType, XmlPullParser xpp, Condition owner, Condition.ConditionEvidenceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.getDetail().add(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance parseConformance(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance res = new Conformance();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceContent(int eventType, XmlPullParser xpp, Conformance res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseConformanceConformanceContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("copyright")) {
- res.setCopyrightElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("kind")) {
- res.setKindElement(parseEnumeration(xpp, Conformance.ConformanceStatementKind.NULL, new Conformance.ConformanceStatementKindEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("software")) {
- res.setSoftware(parseConformanceConformanceSoftwareComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("implementation")) {
- res.setImplementation(parseConformanceConformanceImplementationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fhirVersion")) {
- res.setFhirVersionElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("acceptUnknown")) {
- res.setAcceptUnknownElement(parseEnumeration(xpp, Conformance.UnknownContentCode.NULL, new Conformance.UnknownContentCodeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("format")) {
- res.getFormat().add(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.getProfile().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rest")) {
- res.getRest().add(parseConformanceConformanceRestComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("messaging")) {
- res.getMessaging().add(parseConformanceConformanceMessagingComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("document")) {
- res.getDocument().add(parseConformanceConformanceDocumentComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceContactComponent parseConformanceConformanceContactComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceContactComponent res = new Conformance.ConformanceContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceContactComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceSoftwareComponent parseConformanceConformanceSoftwareComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceSoftwareComponent res = new Conformance.ConformanceSoftwareComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceSoftwareComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceSoftwareComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceSoftwareComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("releaseDate")) {
- res.setReleaseDateElement(parseDateTime(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceImplementationComponent parseConformanceConformanceImplementationComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceImplementationComponent res = new Conformance.ConformanceImplementationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceImplementationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceImplementationComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceImplementationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceRestComponent parseConformanceConformanceRestComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceRestComponent res = new Conformance.ConformanceRestComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceRestComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceRestComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceRestComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mode")) {
- res.setModeElement(parseEnumeration(xpp, Conformance.RestfulConformanceMode.NULL, new Conformance.RestfulConformanceModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("security")) {
- res.setSecurity(parseConformanceConformanceRestSecurityComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.getResource().add(parseConformanceConformanceRestResourceComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("interaction")) {
- res.getInteraction().add(parseConformanceSystemInteractionComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("transactionMode")) {
- res.setTransactionModeElement(parseEnumeration(xpp, Conformance.TransactionMode.NULL, new Conformance.TransactionModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("searchParam")) {
- res.getSearchParam().add(parseConformanceConformanceRestResourceSearchParamComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("operation")) {
- res.getOperation().add(parseConformanceConformanceRestOperationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("compartment")) {
- res.getCompartment().add(parseUri(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceRestSecurityComponent parseConformanceConformanceRestSecurityComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceRestSecurityComponent res = new Conformance.ConformanceRestSecurityComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceRestSecurityComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceRestSecurityComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceRestSecurityComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("cors")) {
- res.setCorsElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("service")) {
- res.getService().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("certificate")) {
- res.getCertificate().add(parseConformanceConformanceRestSecurityCertificateComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceRestSecurityCertificateComponent parseConformanceConformanceRestSecurityCertificateComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceRestSecurityCertificateComponent res = new Conformance.ConformanceRestSecurityCertificateComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceRestSecurityCertificateComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceRestSecurityCertificateComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceRestSecurityCertificateComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("blob")) {
- res.setBlobElement(parseBase64Binary(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceRestResourceComponent parseConformanceConformanceRestResourceComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceRestResourceComponent res = new Conformance.ConformanceRestResourceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceRestResourceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceRestResourceComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceRestResourceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.setProfile(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("interaction")) {
- res.getInteraction().add(parseConformanceResourceInteractionComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("versioning")) {
- res.setVersioningElement(parseEnumeration(xpp, Conformance.ResourceVersionPolicy.NULL, new Conformance.ResourceVersionPolicyEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("readHistory")) {
- res.setReadHistoryElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("updateCreate")) {
- res.setUpdateCreateElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("conditionalCreate")) {
- res.setConditionalCreateElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("conditionalUpdate")) {
- res.setConditionalUpdateElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("conditionalDelete")) {
- res.setConditionalDeleteElement(parseEnumeration(xpp, Conformance.ConditionalDeleteStatus.NULL, new Conformance.ConditionalDeleteStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("searchInclude")) {
- res.getSearchInclude().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("searchRevInclude")) {
- res.getSearchRevInclude().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("searchParam")) {
- res.getSearchParam().add(parseConformanceConformanceRestResourceSearchParamComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ResourceInteractionComponent parseConformanceResourceInteractionComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ResourceInteractionComponent res = new Conformance.ResourceInteractionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceResourceInteractionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceResourceInteractionComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ResourceInteractionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseEnumeration(xpp, Conformance.TypeRestfulInteraction.NULL, new Conformance.TypeRestfulInteractionEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceRestResourceSearchParamComponent parseConformanceConformanceRestResourceSearchParamComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceRestResourceSearchParamComponent res = new Conformance.ConformanceRestResourceSearchParamComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceRestResourceSearchParamComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceRestResourceSearchParamComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceRestResourceSearchParamComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("definition")) {
- res.setDefinitionElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Enumerations.SearchParamType.NULL, new Enumerations.SearchParamTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.getTarget().add(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("modifier")) {
- res.getModifier().add(parseEnumeration(xpp, Conformance.SearchModifierCode.NULL, new Conformance.SearchModifierCodeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("chain")) {
- res.getChain().add(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.SystemInteractionComponent parseConformanceSystemInteractionComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.SystemInteractionComponent res = new Conformance.SystemInteractionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceSystemInteractionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceSystemInteractionComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.SystemInteractionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseEnumeration(xpp, Conformance.SystemRestfulInteraction.NULL, new Conformance.SystemRestfulInteractionEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceRestOperationComponent parseConformanceConformanceRestOperationComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceRestOperationComponent res = new Conformance.ConformanceRestOperationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceRestOperationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceRestOperationComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceRestOperationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("definition")) {
- res.setDefinition(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceMessagingComponent parseConformanceConformanceMessagingComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceMessagingComponent res = new Conformance.ConformanceMessagingComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceMessagingComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceMessagingComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceMessagingComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("endpoint")) {
- res.getEndpoint().add(parseConformanceConformanceMessagingEndpointComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reliableCache")) {
- res.setReliableCacheElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("event")) {
- res.getEvent().add(parseConformanceConformanceMessagingEventComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceMessagingEndpointComponent parseConformanceConformanceMessagingEndpointComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceMessagingEndpointComponent res = new Conformance.ConformanceMessagingEndpointComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceMessagingEndpointComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceMessagingEndpointComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceMessagingEndpointComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("protocol")) {
- res.setProtocol(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("address")) {
- res.setAddressElement(parseUri(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceMessagingEventComponent parseConformanceConformanceMessagingEventComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceMessagingEventComponent res = new Conformance.ConformanceMessagingEventComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceMessagingEventComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceMessagingEventComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceMessagingEventComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategoryElement(parseEnumeration(xpp, Conformance.MessageSignificanceCategory.NULL, new Conformance.MessageSignificanceCategoryEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mode")) {
- res.setModeElement(parseEnumeration(xpp, Conformance.ConformanceEventMode.NULL, new Conformance.ConformanceEventModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("focus")) {
- res.setFocusElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("request")) {
- res.setRequest(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("response")) {
- res.setResponse(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Conformance.ConformanceDocumentComponent parseConformanceConformanceDocumentComponent(XmlPullParser xpp, Conformance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Conformance.ConformanceDocumentComponent res = new Conformance.ConformanceDocumentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConformanceConformanceDocumentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConformanceConformanceDocumentComponentContent(int eventType, XmlPullParser xpp, Conformance owner, Conformance.ConformanceDocumentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mode")) {
- res.setModeElement(parseEnumeration(xpp, Conformance.DocumentMode.NULL, new Conformance.DocumentModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.setProfile(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Consent parseConsent(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Consent res = new Consent();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConsentContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConsentContent(int eventType, XmlPullParser xpp, Consent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Consent.ConsentStatus.NULL, new Consent.ConsentStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("issued")) {
- res.setIssuedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("applies")) {
- res.setApplies(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("topic")) {
- res.getTopic().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("authority")) {
- res.getAuthority().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("domain")) {
- res.getDomain().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("agent")) {
- res.getAgent().add(parseConsentAgentComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("except")) {
- res.getExcept().add(parseConsentExceptComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("friendly")) {
- res.getFriendly().add(parseConsentFriendlyLanguageComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("legal")) {
- res.getLegal().add(parseConsentLegalLanguageComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rule")) {
- res.getRule().add(parseAttachment(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Consent.AgentComponent parseConsentAgentComponent(XmlPullParser xpp, Consent owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Consent.AgentComponent res = new Consent.AgentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConsentAgentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConsentAgentComponentContent(int eventType, XmlPullParser xpp, Consent owner, Consent.AgentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.getRole().add(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Consent.ExceptComponent parseConsentExceptComponent(XmlPullParser xpp, Consent owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Consent.ExceptComponent res = new Consent.ExceptComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConsentExceptComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConsentExceptComponentContent(int eventType, XmlPullParser xpp, Consent owner, Consent.ExceptComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("applies")) {
- res.setApplies(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subType")) {
- res.setSubType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("topic")) {
- res.getTopic().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("agent")) {
- res.getAgent().add(parseConsentExceptAgentComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Consent.ExceptAgentComponent parseConsentExceptAgentComponent(XmlPullParser xpp, Consent owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Consent.ExceptAgentComponent res = new Consent.ExceptAgentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConsentExceptAgentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConsentExceptAgentComponentContent(int eventType, XmlPullParser xpp, Consent owner, Consent.ExceptAgentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.getRole().add(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Consent.FriendlyLanguageComponent parseConsentFriendlyLanguageComponent(XmlPullParser xpp, Consent owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Consent.FriendlyLanguageComponent res = new Consent.FriendlyLanguageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConsentFriendlyLanguageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConsentFriendlyLanguageComponentContent(int eventType, XmlPullParser xpp, Consent owner, Consent.FriendlyLanguageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "content")) {
- res.setContent(parseType("content", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Consent.LegalLanguageComponent parseConsentLegalLanguageComponent(XmlPullParser xpp, Consent owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Consent.LegalLanguageComponent res = new Consent.LegalLanguageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseConsentLegalLanguageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseConsentLegalLanguageComponentContent(int eventType, XmlPullParser xpp, Consent owner, Consent.LegalLanguageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "content")) {
- res.setContent(parseType("content", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Contract parseContract(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Contract res = new Contract();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseContractContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseContractContent(int eventType, XmlPullParser xpp, Contract res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("issued")) {
- res.setIssuedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("applies")) {
- res.setApplies(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.getSubject().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("topic")) {
- res.getTopic().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("authority")) {
- res.getAuthority().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("domain")) {
- res.getDomain().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subType")) {
- res.getSubType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actionReason")) {
- res.getActionReason().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("agent")) {
- res.getAgent().add(parseContractAgentComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("signer")) {
- res.getSigner().add(parseContractSignatoryComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("valuedItem")) {
- res.getValuedItem().add(parseContractValuedItemComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("term")) {
- res.getTerm().add(parseContractTermComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "binding")) {
- res.setBinding(parseType("binding", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("friendly")) {
- res.getFriendly().add(parseContractFriendlyLanguageComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("legal")) {
- res.getLegal().add(parseContractLegalLanguageComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rule")) {
- res.getRule().add(parseContractComputableLanguageComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Contract.AgentComponent parseContractAgentComponent(XmlPullParser xpp, Contract owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Contract.AgentComponent res = new Contract.AgentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseContractAgentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseContractAgentComponentContent(int eventType, XmlPullParser xpp, Contract owner, Contract.AgentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.getRole().add(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Contract.SignatoryComponent parseContractSignatoryComponent(XmlPullParser xpp, Contract owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Contract.SignatoryComponent res = new Contract.SignatoryComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseContractSignatoryComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseContractSignatoryComponentContent(int eventType, XmlPullParser xpp, Contract owner, Contract.SignatoryComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("party")) {
- res.setParty(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("signature")) {
- res.getSignature().add(parseSignature(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Contract.ValuedItemComponent parseContractValuedItemComponent(XmlPullParser xpp, Contract owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Contract.ValuedItemComponent res = new Contract.ValuedItemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseContractValuedItemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseContractValuedItemComponentContent(int eventType, XmlPullParser xpp, Contract owner, Contract.ValuedItemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "entity")) {
- res.setEntity(parseType("entity", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("effectiveTime")) {
- res.setEffectiveTimeElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unitPrice")) {
- res.setUnitPrice(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("factor")) {
- res.setFactorElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("points")) {
- res.setPointsElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("net")) {
- res.setNet(parseMoney(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Contract.TermComponent parseContractTermComponent(XmlPullParser xpp, Contract owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Contract.TermComponent res = new Contract.TermComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseContractTermComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseContractTermComponentContent(int eventType, XmlPullParser xpp, Contract owner, Contract.TermComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("issued")) {
- res.setIssuedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("applies")) {
- res.setApplies(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subType")) {
- res.setSubType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("topic")) {
- res.getTopic().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actionReason")) {
- res.getActionReason().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("agent")) {
- res.getAgent().add(parseContractTermAgentComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("valuedItem")) {
- res.getValuedItem().add(parseContractTermValuedItemComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("group")) {
- res.getGroup().add(parseContractTermComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Contract.TermAgentComponent parseContractTermAgentComponent(XmlPullParser xpp, Contract owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Contract.TermAgentComponent res = new Contract.TermAgentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseContractTermAgentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseContractTermAgentComponentContent(int eventType, XmlPullParser xpp, Contract owner, Contract.TermAgentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.getRole().add(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Contract.TermValuedItemComponent parseContractTermValuedItemComponent(XmlPullParser xpp, Contract owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Contract.TermValuedItemComponent res = new Contract.TermValuedItemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseContractTermValuedItemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseContractTermValuedItemComponentContent(int eventType, XmlPullParser xpp, Contract owner, Contract.TermValuedItemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "entity")) {
- res.setEntity(parseType("entity", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("effectiveTime")) {
- res.setEffectiveTimeElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unitPrice")) {
- res.setUnitPrice(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("factor")) {
- res.setFactorElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("points")) {
- res.setPointsElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("net")) {
- res.setNet(parseMoney(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Contract.FriendlyLanguageComponent parseContractFriendlyLanguageComponent(XmlPullParser xpp, Contract owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Contract.FriendlyLanguageComponent res = new Contract.FriendlyLanguageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseContractFriendlyLanguageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseContractFriendlyLanguageComponentContent(int eventType, XmlPullParser xpp, Contract owner, Contract.FriendlyLanguageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "content")) {
- res.setContent(parseType("content", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Contract.LegalLanguageComponent parseContractLegalLanguageComponent(XmlPullParser xpp, Contract owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Contract.LegalLanguageComponent res = new Contract.LegalLanguageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseContractLegalLanguageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseContractLegalLanguageComponentContent(int eventType, XmlPullParser xpp, Contract owner, Contract.LegalLanguageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "content")) {
- res.setContent(parseType("content", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Contract.ComputableLanguageComponent parseContractComputableLanguageComponent(XmlPullParser xpp, Contract owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Contract.ComputableLanguageComponent res = new Contract.ComputableLanguageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseContractComputableLanguageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseContractComputableLanguageComponentContent(int eventType, XmlPullParser xpp, Contract owner, Contract.ComputableLanguageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "content")) {
- res.setContent(parseType("content", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Coverage parseCoverage(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Coverage res = new Coverage();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseCoverageContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseCoverageContent(int eventType, XmlPullParser xpp, Coverage res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "issuer")) {
- res.setIssuer(parseType("issuer", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("isAgreement")) {
- res.setIsAgreementElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("bin")) {
- res.setBinElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "planholder")) {
- res.setPlanholder(parseType("planholder", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "beneficiary")) {
- res.setBeneficiary(parseType("beneficiary", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relationship")) {
- res.setRelationship(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("group")) {
- res.setGroupElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("plan")) {
- res.setPlanElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subPlan")) {
- res.setSubPlanElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dependent")) {
- res.setDependentElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("exception")) {
- res.getException().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("school")) {
- res.setSchoolElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("network")) {
- res.setNetworkElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contract")) {
- res.getContract().add(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DataElement parseDataElement(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DataElement res = new DataElement();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDataElementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDataElementContent(int eventType, XmlPullParser xpp, DataElement res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseDataElementDataElementContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("copyright")) {
- res.setCopyrightElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("stringency")) {
- res.setStringencyElement(parseEnumeration(xpp, DataElement.DataElementStringency.NULL, new DataElement.DataElementStringencyEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mapping")) {
- res.getMapping().add(parseDataElementDataElementMappingComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("element")) {
- res.getElement().add(parseElementDefinition(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DataElement.DataElementContactComponent parseDataElementDataElementContactComponent(XmlPullParser xpp, DataElement owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DataElement.DataElementContactComponent res = new DataElement.DataElementContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDataElementDataElementContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDataElementDataElementContactComponentContent(int eventType, XmlPullParser xpp, DataElement owner, DataElement.DataElementContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DataElement.DataElementMappingComponent parseDataElementDataElementMappingComponent(XmlPullParser xpp, DataElement owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DataElement.DataElementMappingComponent res = new DataElement.DataElementMappingComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDataElementDataElementMappingComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDataElementDataElementMappingComponentContent(int eventType, XmlPullParser xpp, DataElement owner, DataElement.DataElementMappingComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identity")) {
- res.setIdentityElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("uri")) {
- res.setUriElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comment")) {
- res.setCommentElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DecisionSupportRule parseDecisionSupportRule(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DecisionSupportRule res = new DecisionSupportRule();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDecisionSupportRuleContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDecisionSupportRuleContent(int eventType, XmlPullParser xpp, DecisionSupportRule res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("moduleMetadata")) {
- res.setModuleMetadata(parseModuleMetadata(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("library")) {
- res.getLibrary().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("trigger")) {
- res.getTrigger().add(parseTriggerDefinition(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("condition")) {
- res.setConditionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseActionDefinition(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DecisionSupportServiceModule parseDecisionSupportServiceModule(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DecisionSupportServiceModule res = new DecisionSupportServiceModule();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDecisionSupportServiceModuleContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDecisionSupportServiceModuleContent(int eventType, XmlPullParser xpp, DecisionSupportServiceModule res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("moduleMetadata")) {
- res.setModuleMetadata(parseModuleMetadata(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("trigger")) {
- res.getTrigger().add(parseTriggerDefinition(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parameter")) {
- res.getParameter().add(parseParameterDefinition(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dataRequirement")) {
- res.getDataRequirement().add(parseDataRequirement(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DetectedIssue parseDetectedIssue(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DetectedIssue res = new DetectedIssue();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDetectedIssueContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDetectedIssueContent(int eventType, XmlPullParser xpp, DetectedIssue res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("severity")) {
- res.setSeverityElement(parseEnumeration(xpp, DetectedIssue.DetectedIssueSeverity.NULL, new DetectedIssue.DetectedIssueSeverityEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("implicated")) {
- res.getImplicated().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.setDetailElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.setAuthor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reference")) {
- res.setReferenceElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mitigation")) {
- res.getMitigation().add(parseDetectedIssueDetectedIssueMitigationComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DetectedIssue.DetectedIssueMitigationComponent parseDetectedIssueDetectedIssueMitigationComponent(XmlPullParser xpp, DetectedIssue owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DetectedIssue.DetectedIssueMitigationComponent res = new DetectedIssue.DetectedIssueMitigationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDetectedIssueDetectedIssueMitigationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDetectedIssueDetectedIssueMitigationComponentContent(int eventType, XmlPullParser xpp, DetectedIssue owner, DetectedIssue.DetectedIssueMitigationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.setAction(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.setAuthor(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Device parseDevice(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Device res = new Device();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDeviceContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDeviceContent(int eventType, XmlPullParser xpp, Device res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("udiCarrier")) {
- res.setUdiCarrier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Device.DeviceStatus.NULL, new Device.DeviceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lotNumber")) {
- res.setLotNumberElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("manufacturer")) {
- res.setManufacturerElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("manufactureDate")) {
- res.setManufactureDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("expirationDate")) {
- res.setExpirationDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("model")) {
- res.setModelElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("owner")) {
- res.setOwner(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.setLocation(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DeviceComponent parseDeviceComponent(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DeviceComponent res = new DeviceComponent();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDeviceComponentContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDeviceComponentContent(int eventType, XmlPullParser xpp, DeviceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lastSystemChange")) {
- res.setLastSystemChangeElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("source")) {
- res.setSource(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parent")) {
- res.setParent(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("operationalStatus")) {
- res.getOperationalStatus().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parameterGroup")) {
- res.setParameterGroup(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("measurementPrinciple")) {
- res.setMeasurementPrincipleElement(parseEnumeration(xpp, DeviceComponent.MeasmntPrinciple.NULL, new DeviceComponent.MeasmntPrincipleEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("productionSpecification")) {
- res.getProductionSpecification().add(parseDeviceComponentDeviceComponentProductionSpecificationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("languageCode")) {
- res.setLanguageCode(parseCodeableConcept(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DeviceComponent.DeviceComponentProductionSpecificationComponent parseDeviceComponentDeviceComponentProductionSpecificationComponent(XmlPullParser xpp, DeviceComponent owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DeviceComponent.DeviceComponentProductionSpecificationComponent res = new DeviceComponent.DeviceComponentProductionSpecificationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDeviceComponentDeviceComponentProductionSpecificationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDeviceComponentDeviceComponentProductionSpecificationComponentContent(int eventType, XmlPullParser xpp, DeviceComponent owner, DeviceComponent.DeviceComponentProductionSpecificationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specType")) {
- res.setSpecType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("componentId")) {
- res.setComponentId(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("productionSpec")) {
- res.setProductionSpecElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DeviceMetric parseDeviceMetric(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DeviceMetric res = new DeviceMetric();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDeviceMetricContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDeviceMetricContent(int eventType, XmlPullParser xpp, DeviceMetric res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unit")) {
- res.setUnit(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("source")) {
- res.setSource(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parent")) {
- res.setParent(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("operationalStatus")) {
- res.setOperationalStatusElement(parseEnumeration(xpp, DeviceMetric.DeviceMetricOperationalStatus.NULL, new DeviceMetric.DeviceMetricOperationalStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("color")) {
- res.setColorElement(parseEnumeration(xpp, DeviceMetric.DeviceMetricColor.NULL, new DeviceMetric.DeviceMetricColorEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategoryElement(parseEnumeration(xpp, DeviceMetric.DeviceMetricCategory.NULL, new DeviceMetric.DeviceMetricCategoryEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("measurementPeriod")) {
- res.setMeasurementPeriod(parseTiming(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("calibration")) {
- res.getCalibration().add(parseDeviceMetricDeviceMetricCalibrationComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DeviceMetric.DeviceMetricCalibrationComponent parseDeviceMetricDeviceMetricCalibrationComponent(XmlPullParser xpp, DeviceMetric owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DeviceMetric.DeviceMetricCalibrationComponent res = new DeviceMetric.DeviceMetricCalibrationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDeviceMetricDeviceMetricCalibrationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDeviceMetricDeviceMetricCalibrationComponentContent(int eventType, XmlPullParser xpp, DeviceMetric owner, DeviceMetric.DeviceMetricCalibrationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, DeviceMetric.DeviceMetricCalibrationType.NULL, new DeviceMetric.DeviceMetricCalibrationTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("state")) {
- res.setStateElement(parseEnumeration(xpp, DeviceMetric.DeviceMetricCalibrationState.NULL, new DeviceMetric.DeviceMetricCalibrationStateEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("time")) {
- res.setTimeElement(parseInstant(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DeviceUseRequest parseDeviceUseRequest(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DeviceUseRequest res = new DeviceUseRequest();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDeviceUseRequestContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDeviceUseRequestContent(int eventType, XmlPullParser xpp, DeviceUseRequest res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "bodySite")) {
- res.setBodySite(parseType("bodySite", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, DeviceUseRequest.DeviceUseRequestStatus.NULL, new DeviceUseRequest.DeviceUseRequestStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("device")) {
- res.setDevice(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("indication")) {
- res.getIndication().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("notes")) {
- res.getNotes().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prnReason")) {
- res.getPrnReason().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("orderedOn")) {
- res.setOrderedOnElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recordedOn")) {
- res.setRecordedOnElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "timing")) {
- res.setTiming(parseType("timing", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priority")) {
- res.setPriorityElement(parseEnumeration(xpp, DeviceUseRequest.DeviceUseRequestPriority.NULL, new DeviceUseRequest.DeviceUseRequestPriorityEnumFactory()));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DeviceUseStatement parseDeviceUseStatement(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DeviceUseStatement res = new DeviceUseStatement();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDeviceUseStatementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDeviceUseStatementContent(int eventType, XmlPullParser xpp, DeviceUseStatement res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "bodySite")) {
- res.setBodySite(parseType("bodySite", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("whenUsed")) {
- res.setWhenUsed(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("device")) {
- res.setDevice(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("indication")) {
- res.getIndication().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("notes")) {
- res.getNotes().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recordedOn")) {
- res.setRecordedOnElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "timing")) {
- res.setTiming(parseType("timing", xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DiagnosticOrder parseDiagnosticOrder(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DiagnosticOrder res = new DiagnosticOrder();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDiagnosticOrderContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDiagnosticOrderContent(int eventType, XmlPullParser xpp, DiagnosticOrder res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, DiagnosticOrder.DiagnosticOrderStatus.NULL, new DiagnosticOrder.DiagnosticOrderStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priority")) {
- res.setPriorityElement(parseEnumeration(xpp, DiagnosticOrder.DiagnosticOrderPriority.NULL, new DiagnosticOrder.DiagnosticOrderPriorityEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("orderer")) {
- res.setOrderer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.getReason().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supportingInformation")) {
- res.getSupportingInformation().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("event")) {
- res.getEvent().add(parseDiagnosticOrderDiagnosticOrderEventComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseDiagnosticOrderDiagnosticOrderItemComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DiagnosticOrder.DiagnosticOrderEventComponent parseDiagnosticOrderDiagnosticOrderEventComponent(XmlPullParser xpp, DiagnosticOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DiagnosticOrder.DiagnosticOrderEventComponent res = new DiagnosticOrder.DiagnosticOrderEventComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDiagnosticOrderDiagnosticOrderEventComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDiagnosticOrderDiagnosticOrderEventComponentContent(int eventType, XmlPullParser xpp, DiagnosticOrder owner, DiagnosticOrder.DiagnosticOrderEventComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, DiagnosticOrder.DiagnosticOrderStatus.NULL, new DiagnosticOrder.DiagnosticOrderStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescription(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateTime")) {
- res.setDateTimeElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DiagnosticOrder.DiagnosticOrderItemComponent parseDiagnosticOrderDiagnosticOrderItemComponent(XmlPullParser xpp, DiagnosticOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DiagnosticOrder.DiagnosticOrderItemComponent res = new DiagnosticOrder.DiagnosticOrderItemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDiagnosticOrderDiagnosticOrderItemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDiagnosticOrderDiagnosticOrderItemComponentContent(int eventType, XmlPullParser xpp, DiagnosticOrder owner, DiagnosticOrder.DiagnosticOrderItemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("bodySite")) {
- res.setBodySite(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, DiagnosticOrder.DiagnosticOrderStatus.NULL, new DiagnosticOrder.DiagnosticOrderStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("event")) {
- res.getEvent().add(parseDiagnosticOrderDiagnosticOrderEventComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DiagnosticReport parseDiagnosticReport(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DiagnosticReport res = new DiagnosticReport();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDiagnosticReportContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDiagnosticReportContent(int eventType, XmlPullParser xpp, DiagnosticReport res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, DiagnosticReport.DiagnosticReportStatus.NULL, new DiagnosticReport.DiagnosticReportStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "effective")) {
- res.setEffective(parseType("effective", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("issued")) {
- res.setIssuedElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("performer")) {
- res.getPerformer().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("request")) {
- res.getRequest().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specimen")) {
- res.getSpecimen().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("result")) {
- res.getResult().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("imagingStudy")) {
- res.getImagingStudy().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("image")) {
- res.getImage().add(parseDiagnosticReportDiagnosticReportImageComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("conclusion")) {
- res.setConclusionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("codedDiagnosis")) {
- res.getCodedDiagnosis().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("presentedForm")) {
- res.getPresentedForm().add(parseAttachment(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DiagnosticReport.DiagnosticReportImageComponent parseDiagnosticReportDiagnosticReportImageComponent(XmlPullParser xpp, DiagnosticReport owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DiagnosticReport.DiagnosticReportImageComponent res = new DiagnosticReport.DiagnosticReportImageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDiagnosticReportDiagnosticReportImageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDiagnosticReportDiagnosticReportImageComponentContent(int eventType, XmlPullParser xpp, DiagnosticReport owner, DiagnosticReport.DiagnosticReportImageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comment")) {
- res.setCommentElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("link")) {
- res.setLink(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DocumentManifest parseDocumentManifest(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DocumentManifest res = new DocumentManifest();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDocumentManifestContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDocumentManifestContent(int eventType, XmlPullParser xpp, DocumentManifest res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("masterIdentifier")) {
- res.setMasterIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recipient")) {
- res.getRecipient().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.getAuthor().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("source")) {
- res.setSourceElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.DocumentReferenceStatus.NULL, new Enumerations.DocumentReferenceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("content")) {
- res.getContent().add(parseDocumentManifestDocumentManifestContentComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("related")) {
- res.getRelated().add(parseDocumentManifestDocumentManifestRelatedComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DocumentManifest.DocumentManifestContentComponent parseDocumentManifestDocumentManifestContentComponent(XmlPullParser xpp, DocumentManifest owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DocumentManifest.DocumentManifestContentComponent res = new DocumentManifest.DocumentManifestContentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDocumentManifestDocumentManifestContentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDocumentManifestDocumentManifestContentComponentContent(int eventType, XmlPullParser xpp, DocumentManifest owner, DocumentManifest.DocumentManifestContentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "p")) {
- res.setP(parseType("p", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DocumentManifest.DocumentManifestRelatedComponent parseDocumentManifestDocumentManifestRelatedComponent(XmlPullParser xpp, DocumentManifest owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DocumentManifest.DocumentManifestRelatedComponent res = new DocumentManifest.DocumentManifestRelatedComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDocumentManifestDocumentManifestRelatedComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDocumentManifestDocumentManifestRelatedComponentContent(int eventType, XmlPullParser xpp, DocumentManifest owner, DocumentManifest.DocumentManifestRelatedComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ref")) {
- res.setRef(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DocumentReference parseDocumentReference(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- DocumentReference res = new DocumentReference();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDocumentReferenceContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDocumentReferenceContent(int eventType, XmlPullParser xpp, DocumentReference res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("masterIdentifier")) {
- res.setMasterIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("class")) {
- res.setClass_(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.getAuthor().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("custodian")) {
- res.setCustodian(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("authenticator")) {
- res.setAuthenticator(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("indexed")) {
- res.setIndexedElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.DocumentReferenceStatus.NULL, new Enumerations.DocumentReferenceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("docStatus")) {
- res.setDocStatus(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relatesTo")) {
- res.getRelatesTo().add(parseDocumentReferenceDocumentReferenceRelatesToComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("securityLabel")) {
- res.getSecurityLabel().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("content")) {
- res.getContent().add(parseDocumentReferenceDocumentReferenceContentComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("context")) {
- res.setContext(parseDocumentReferenceDocumentReferenceContextComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DocumentReference.DocumentReferenceRelatesToComponent parseDocumentReferenceDocumentReferenceRelatesToComponent(XmlPullParser xpp, DocumentReference owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DocumentReference.DocumentReferenceRelatesToComponent res = new DocumentReference.DocumentReferenceRelatesToComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDocumentReferenceDocumentReferenceRelatesToComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDocumentReferenceDocumentReferenceRelatesToComponentContent(int eventType, XmlPullParser xpp, DocumentReference owner, DocumentReference.DocumentReferenceRelatesToComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseEnumeration(xpp, DocumentReference.DocumentRelationshipType.NULL, new DocumentReference.DocumentRelationshipTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.setTarget(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DocumentReference.DocumentReferenceContentComponent parseDocumentReferenceDocumentReferenceContentComponent(XmlPullParser xpp, DocumentReference owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DocumentReference.DocumentReferenceContentComponent res = new DocumentReference.DocumentReferenceContentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDocumentReferenceDocumentReferenceContentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDocumentReferenceDocumentReferenceContentComponentContent(int eventType, XmlPullParser xpp, DocumentReference owner, DocumentReference.DocumentReferenceContentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("attachment")) {
- res.setAttachment(parseAttachment(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("format")) {
- res.getFormat().add(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DocumentReference.DocumentReferenceContextComponent parseDocumentReferenceDocumentReferenceContextComponent(XmlPullParser xpp, DocumentReference owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DocumentReference.DocumentReferenceContextComponent res = new DocumentReference.DocumentReferenceContextComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDocumentReferenceDocumentReferenceContextComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDocumentReferenceDocumentReferenceContextComponentContent(int eventType, XmlPullParser xpp, DocumentReference owner, DocumentReference.DocumentReferenceContextComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("event")) {
- res.getEvent().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("facilityType")) {
- res.setFacilityType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("practiceSetting")) {
- res.setPracticeSetting(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sourcePatientInfo")) {
- res.setSourcePatientInfo(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("related")) {
- res.getRelated().add(parseDocumentReferenceDocumentReferenceContextRelatedComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected DocumentReference.DocumentReferenceContextRelatedComponent parseDocumentReferenceDocumentReferenceContextRelatedComponent(XmlPullParser xpp, DocumentReference owner) throws XmlPullParserException, IOException, FHIRFormatError {
- DocumentReference.DocumentReferenceContextRelatedComponent res = new DocumentReference.DocumentReferenceContextRelatedComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseDocumentReferenceDocumentReferenceContextRelatedComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseDocumentReferenceDocumentReferenceContextRelatedComponentContent(int eventType, XmlPullParser xpp, DocumentReference owner, DocumentReference.DocumentReferenceContextRelatedComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ref")) {
- res.setRef(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected EligibilityRequest parseEligibilityRequest(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- EligibilityRequest res = new EligibilityRequest();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEligibilityRequestContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEligibilityRequestContent(int eventType, XmlPullParser xpp, EligibilityRequest res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "target")) {
- res.setTarget(parseType("target", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "provider")) {
- res.setProvider(parseType("provider", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "organization")) {
- res.setOrganization(parseType("organization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priority")) {
- res.setPriority(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "enterer")) {
- res.setEnterer(parseType("enterer", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "facility")) {
- res.setFacility(parseType("facility", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "patient")) {
- res.setPatient(parseType("patient", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "coverage")) {
- res.setCoverage(parseType("coverage", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("businessArrangement")) {
- res.setBusinessArrangementElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "serviced")) {
- res.setServiced(parseType("serviced", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("benefitCategory")) {
- res.setBenefitCategory(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("benefitSubCategory")) {
- res.setBenefitSubCategory(parseCoding(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected EligibilityResponse parseEligibilityResponse(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- EligibilityResponse res = new EligibilityResponse();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEligibilityResponseContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEligibilityResponseContent(int eventType, XmlPullParser xpp, EligibilityResponse res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "request")) {
- res.setRequest(parseType("request", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outcome")) {
- res.setOutcomeElement(parseEnumeration(xpp, Enumerations.RemittanceOutcome.NULL, new Enumerations.RemittanceOutcomeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("disposition")) {
- res.setDispositionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "organization")) {
- res.setOrganization(parseType("organization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "requestProvider")) {
- res.setRequestProvider(parseType("requestProvider", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "requestOrganization")) {
- res.setRequestOrganization(parseType("requestOrganization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("inforce")) {
- res.setInforceElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contract")) {
- res.setContract(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("form")) {
- res.setForm(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("benefitBalance")) {
- res.getBenefitBalance().add(parseEligibilityResponseBenefitsComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("error")) {
- res.getError().add(parseEligibilityResponseErrorsComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected EligibilityResponse.BenefitsComponent parseEligibilityResponseBenefitsComponent(XmlPullParser xpp, EligibilityResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- EligibilityResponse.BenefitsComponent res = new EligibilityResponse.BenefitsComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEligibilityResponseBenefitsComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEligibilityResponseBenefitsComponentContent(int eventType, XmlPullParser xpp, EligibilityResponse owner, EligibilityResponse.BenefitsComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subCategory")) {
- res.setSubCategory(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("network")) {
- res.setNetwork(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unit")) {
- res.setUnit(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("term")) {
- res.setTerm(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("financial")) {
- res.getFinancial().add(parseEligibilityResponseBenefitComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected EligibilityResponse.BenefitComponent parseEligibilityResponseBenefitComponent(XmlPullParser xpp, EligibilityResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- EligibilityResponse.BenefitComponent res = new EligibilityResponse.BenefitComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEligibilityResponseBenefitComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEligibilityResponseBenefitComponentContent(int eventType, XmlPullParser xpp, EligibilityResponse owner, EligibilityResponse.BenefitComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "benefit")) {
- res.setBenefit(parseType("benefit", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "benefitUsed")) {
- res.setBenefitUsed(parseType("benefitUsed", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected EligibilityResponse.ErrorsComponent parseEligibilityResponseErrorsComponent(XmlPullParser xpp, EligibilityResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- EligibilityResponse.ErrorsComponent res = new EligibilityResponse.ErrorsComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEligibilityResponseErrorsComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEligibilityResponseErrorsComponentContent(int eventType, XmlPullParser xpp, EligibilityResponse owner, EligibilityResponse.ErrorsComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Encounter parseEncounter(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Encounter res = new Encounter();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEncounterContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEncounterContent(int eventType, XmlPullParser xpp, Encounter res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Encounter.EncounterState.NULL, new Encounter.EncounterStateEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("statusHistory")) {
- res.getStatusHistory().add(parseEncounterEncounterStatusHistoryComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("class")) {
- res.setClass_Element(parseEnumeration(xpp, Encounter.EncounterClass.NULL, new Encounter.EncounterClassEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priority")) {
- res.setPriority(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("episodeOfCare")) {
- res.getEpisodeOfCare().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("incomingReferral")) {
- res.getIncomingReferral().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("participant")) {
- res.getParticipant().add(parseEncounterEncounterParticipantComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("appointment")) {
- res.setAppointment(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("length")) {
- res.setLength(parseDuration(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.getReason().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("indication")) {
- res.getIndication().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("hospitalization")) {
- res.setHospitalization(parseEncounterEncounterHospitalizationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.getLocation().add(parseEncounterEncounterLocationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceProvider")) {
- res.setServiceProvider(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("partOf")) {
- res.setPartOf(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Encounter.EncounterStatusHistoryComponent parseEncounterEncounterStatusHistoryComponent(XmlPullParser xpp, Encounter owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Encounter.EncounterStatusHistoryComponent res = new Encounter.EncounterStatusHistoryComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEncounterEncounterStatusHistoryComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEncounterEncounterStatusHistoryComponentContent(int eventType, XmlPullParser xpp, Encounter owner, Encounter.EncounterStatusHistoryComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Encounter.EncounterState.NULL, new Encounter.EncounterStateEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Encounter.EncounterParticipantComponent parseEncounterEncounterParticipantComponent(XmlPullParser xpp, Encounter owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Encounter.EncounterParticipantComponent res = new Encounter.EncounterParticipantComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEncounterEncounterParticipantComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEncounterEncounterParticipantComponentContent(int eventType, XmlPullParser xpp, Encounter owner, Encounter.EncounterParticipantComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("individual")) {
- res.setIndividual(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Encounter.EncounterHospitalizationComponent parseEncounterEncounterHospitalizationComponent(XmlPullParser xpp, Encounter owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Encounter.EncounterHospitalizationComponent res = new Encounter.EncounterHospitalizationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEncounterEncounterHospitalizationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEncounterEncounterHospitalizationComponentContent(int eventType, XmlPullParser xpp, Encounter owner, Encounter.EncounterHospitalizationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("preAdmissionIdentifier")) {
- res.setPreAdmissionIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("origin")) {
- res.setOrigin(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("admitSource")) {
- res.setAdmitSource(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("admittingDiagnosis")) {
- res.getAdmittingDiagnosis().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reAdmission")) {
- res.setReAdmission(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dietPreference")) {
- res.getDietPreference().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specialCourtesy")) {
- res.getSpecialCourtesy().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specialArrangement")) {
- res.getSpecialArrangement().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("destination")) {
- res.setDestination(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dischargeDisposition")) {
- res.setDischargeDisposition(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dischargeDiagnosis")) {
- res.getDischargeDiagnosis().add(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Encounter.EncounterLocationComponent parseEncounterEncounterLocationComponent(XmlPullParser xpp, Encounter owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Encounter.EncounterLocationComponent res = new Encounter.EncounterLocationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEncounterEncounterLocationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEncounterEncounterLocationComponentContent(int eventType, XmlPullParser xpp, Encounter owner, Encounter.EncounterLocationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.setLocation(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Encounter.EncounterLocationStatus.NULL, new Encounter.EncounterLocationStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Endpoint parseEndpoint(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Endpoint res = new Endpoint();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEndpointContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEndpointContent(int eventType, XmlPullParser xpp, Endpoint res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Endpoint.EndpointStatus.NULL, new Endpoint.EndpointStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("managingOrganization")) {
- res.setManagingOrganization(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("connectionType")) {
- res.setConnectionTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("method")) {
- res.getMethod().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "address")) {
- res.setAddress(parseType("address", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("payloadFormat")) {
- res.setPayloadFormatElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("payloadType")) {
- res.getPayloadType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("header")) {
- res.getHeader().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publicKey")) {
- res.setPublicKeyElement(parseString(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected EnrollmentRequest parseEnrollmentRequest(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- EnrollmentRequest res = new EnrollmentRequest();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEnrollmentRequestContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEnrollmentRequestContent(int eventType, XmlPullParser xpp, EnrollmentRequest res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.setTarget(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("provider")) {
- res.setProvider(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("organization")) {
- res.setOrganization(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("coverage")) {
- res.setCoverage(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relationship")) {
- res.setRelationship(parseCoding(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected EnrollmentResponse parseEnrollmentResponse(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- EnrollmentResponse res = new EnrollmentResponse();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEnrollmentResponseContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEnrollmentResponseContent(int eventType, XmlPullParser xpp, EnrollmentResponse res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("request")) {
- res.setRequest(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outcome")) {
- res.setOutcomeElement(parseEnumeration(xpp, Enumerations.RemittanceOutcome.NULL, new Enumerations.RemittanceOutcomeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("disposition")) {
- res.setDispositionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("organization")) {
- res.setOrganization(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requestProvider")) {
- res.setRequestProvider(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requestOrganization")) {
- res.setRequestOrganization(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected EpisodeOfCare parseEpisodeOfCare(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- EpisodeOfCare res = new EpisodeOfCare();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEpisodeOfCareContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEpisodeOfCareContent(int eventType, XmlPullParser xpp, EpisodeOfCare res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, EpisodeOfCare.EpisodeOfCareStatus.NULL, new EpisodeOfCare.EpisodeOfCareStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("statusHistory")) {
- res.getStatusHistory().add(parseEpisodeOfCareEpisodeOfCareStatusHistoryComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("condition")) {
- res.getCondition().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("managingOrganization")) {
- res.setManagingOrganization(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("referralRequest")) {
- res.getReferralRequest().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("careManager")) {
- res.setCareManager(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("team")) {
- res.getTeam().add(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected EpisodeOfCare.EpisodeOfCareStatusHistoryComponent parseEpisodeOfCareEpisodeOfCareStatusHistoryComponent(XmlPullParser xpp, EpisodeOfCare owner) throws XmlPullParserException, IOException, FHIRFormatError {
- EpisodeOfCare.EpisodeOfCareStatusHistoryComponent res = new EpisodeOfCare.EpisodeOfCareStatusHistoryComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseEpisodeOfCareEpisodeOfCareStatusHistoryComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseEpisodeOfCareEpisodeOfCareStatusHistoryComponentContent(int eventType, XmlPullParser xpp, EpisodeOfCare owner, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, EpisodeOfCare.EpisodeOfCareStatus.NULL, new EpisodeOfCare.EpisodeOfCareStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile parseExpansionProfile(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile res = new ExpansionProfile();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileContent(int eventType, XmlPullParser xpp, ExpansionProfile res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseExpansionProfileExpansionProfileContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("codeSystem")) {
- res.setCodeSystem(parseExpansionProfileExpansionProfileCodeSystemComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("includeDesignations")) {
- res.setIncludeDesignationsElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("designation")) {
- res.setDesignation(parseExpansionProfileExpansionProfileDesignationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("includeDefinition")) {
- res.setIncludeDefinitionElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("includeInactive")) {
- res.setIncludeInactiveElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("excludeNested")) {
- res.setExcludeNestedElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("excludeNotForUI")) {
- res.setExcludeNotForUIElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("excludePostCoordinated")) {
- res.setExcludePostCoordinatedElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("displayLanguage")) {
- res.setDisplayLanguageElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("limitedExpansion")) {
- res.setLimitedExpansionElement(parseBoolean(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile.ExpansionProfileContactComponent parseExpansionProfileExpansionProfileContactComponent(XmlPullParser xpp, ExpansionProfile owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile.ExpansionProfileContactComponent res = new ExpansionProfile.ExpansionProfileContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileExpansionProfileContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileExpansionProfileContactComponentContent(int eventType, XmlPullParser xpp, ExpansionProfile owner, ExpansionProfile.ExpansionProfileContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile.ExpansionProfileCodeSystemComponent parseExpansionProfileExpansionProfileCodeSystemComponent(XmlPullParser xpp, ExpansionProfile owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile.ExpansionProfileCodeSystemComponent res = new ExpansionProfile.ExpansionProfileCodeSystemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileExpansionProfileCodeSystemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileExpansionProfileCodeSystemComponentContent(int eventType, XmlPullParser xpp, ExpansionProfile owner, ExpansionProfile.ExpansionProfileCodeSystemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("include")) {
- res.setInclude(parseExpansionProfileCodeSystemIncludeComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("exclude")) {
- res.setExclude(parseExpansionProfileCodeSystemExcludeComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile.CodeSystemIncludeComponent parseExpansionProfileCodeSystemIncludeComponent(XmlPullParser xpp, ExpansionProfile owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile.CodeSystemIncludeComponent res = new ExpansionProfile.CodeSystemIncludeComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileCodeSystemIncludeComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileCodeSystemIncludeComponentContent(int eventType, XmlPullParser xpp, ExpansionProfile owner, ExpansionProfile.CodeSystemIncludeComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("codeSystem")) {
- res.getCodeSystem().add(parseExpansionProfileCodeSystemIncludeCodeSystemComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile.CodeSystemIncludeCodeSystemComponent parseExpansionProfileCodeSystemIncludeCodeSystemComponent(XmlPullParser xpp, ExpansionProfile owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile.CodeSystemIncludeCodeSystemComponent res = new ExpansionProfile.CodeSystemIncludeCodeSystemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileCodeSystemIncludeCodeSystemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileCodeSystemIncludeCodeSystemComponentContent(int eventType, XmlPullParser xpp, ExpansionProfile owner, ExpansionProfile.CodeSystemIncludeCodeSystemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile.CodeSystemExcludeComponent parseExpansionProfileCodeSystemExcludeComponent(XmlPullParser xpp, ExpansionProfile owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile.CodeSystemExcludeComponent res = new ExpansionProfile.CodeSystemExcludeComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileCodeSystemExcludeComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileCodeSystemExcludeComponentContent(int eventType, XmlPullParser xpp, ExpansionProfile owner, ExpansionProfile.CodeSystemExcludeComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("codeSystem")) {
- res.getCodeSystem().add(parseExpansionProfileCodeSystemExcludeCodeSystemComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile.CodeSystemExcludeCodeSystemComponent parseExpansionProfileCodeSystemExcludeCodeSystemComponent(XmlPullParser xpp, ExpansionProfile owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile.CodeSystemExcludeCodeSystemComponent res = new ExpansionProfile.CodeSystemExcludeCodeSystemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileCodeSystemExcludeCodeSystemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileCodeSystemExcludeCodeSystemComponentContent(int eventType, XmlPullParser xpp, ExpansionProfile owner, ExpansionProfile.CodeSystemExcludeCodeSystemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile.ExpansionProfileDesignationComponent parseExpansionProfileExpansionProfileDesignationComponent(XmlPullParser xpp, ExpansionProfile owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile.ExpansionProfileDesignationComponent res = new ExpansionProfile.ExpansionProfileDesignationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileExpansionProfileDesignationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileExpansionProfileDesignationComponentContent(int eventType, XmlPullParser xpp, ExpansionProfile owner, ExpansionProfile.ExpansionProfileDesignationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("include")) {
- res.setInclude(parseExpansionProfileDesignationIncludeComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("exclude")) {
- res.setExclude(parseExpansionProfileDesignationExcludeComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile.DesignationIncludeComponent parseExpansionProfileDesignationIncludeComponent(XmlPullParser xpp, ExpansionProfile owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile.DesignationIncludeComponent res = new ExpansionProfile.DesignationIncludeComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileDesignationIncludeComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileDesignationIncludeComponentContent(int eventType, XmlPullParser xpp, ExpansionProfile owner, ExpansionProfile.DesignationIncludeComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("designation")) {
- res.getDesignation().add(parseExpansionProfileDesignationIncludeDesignationComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile.DesignationIncludeDesignationComponent parseExpansionProfileDesignationIncludeDesignationComponent(XmlPullParser xpp, ExpansionProfile owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile.DesignationIncludeDesignationComponent res = new ExpansionProfile.DesignationIncludeDesignationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileDesignationIncludeDesignationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileDesignationIncludeDesignationComponentContent(int eventType, XmlPullParser xpp, ExpansionProfile owner, ExpansionProfile.DesignationIncludeDesignationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("language")) {
- res.setLanguageElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUse(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile.DesignationExcludeComponent parseExpansionProfileDesignationExcludeComponent(XmlPullParser xpp, ExpansionProfile owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile.DesignationExcludeComponent res = new ExpansionProfile.DesignationExcludeComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileDesignationExcludeComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileDesignationExcludeComponentContent(int eventType, XmlPullParser xpp, ExpansionProfile owner, ExpansionProfile.DesignationExcludeComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("designation")) {
- res.getDesignation().add(parseExpansionProfileDesignationExcludeDesignationComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExpansionProfile.DesignationExcludeDesignationComponent parseExpansionProfileDesignationExcludeDesignationComponent(XmlPullParser xpp, ExpansionProfile owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExpansionProfile.DesignationExcludeDesignationComponent res = new ExpansionProfile.DesignationExcludeDesignationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExpansionProfileDesignationExcludeDesignationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExpansionProfileDesignationExcludeDesignationComponentContent(int eventType, XmlPullParser xpp, ExpansionProfile owner, ExpansionProfile.DesignationExcludeDesignationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("language")) {
- res.setLanguageElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUse(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit parseExplanationOfBenefit(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit res = new ExplanationOfBenefit();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "claim")) {
- res.setClaim(parseType("claim", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "claimResponse")) {
- res.setClaimResponse(parseType("claimResponse", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, ExplanationOfBenefit.ClaimType2.NULL, new ExplanationOfBenefit.ClaimType2EnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subType")) {
- res.getSubType().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("billablePeriod")) {
- res.setBillablePeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("disposition")) {
- res.setDispositionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "provider")) {
- res.setProvider(parseType("provider", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "organization")) {
- res.setOrganization(parseType("organization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "facility")) {
- res.setFacility(parseType("facility", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("related")) {
- res.getRelated().add(parseExplanationOfBenefitRelatedClaimComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "prescription")) {
- res.setPrescription(parseType("prescription", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "originalPrescription")) {
- res.setOriginalPrescription(parseType("originalPrescription", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("payee")) {
- res.setPayee(parseExplanationOfBenefitPayeeComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "referral")) {
- res.setReferral(parseType("referral", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("information")) {
- res.getInformation().add(parseExplanationOfBenefitInformationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("diagnosis")) {
- res.getDiagnosis().add(parseExplanationOfBenefitDiagnosisComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("procedure")) {
- res.getProcedure().add(parseExplanationOfBenefitProcedureComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "patient")) {
- res.setPatient(parseType("patient", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("precedence")) {
- res.setPrecedenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("coverage")) {
- res.setCoverage(parseExplanationOfBenefitCoverageComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseExplanationOfBenefitItemComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("addItem")) {
- res.getAddItem().add(parseExplanationOfBenefitAddedItemComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("totalCost")) {
- res.setTotalCost(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unallocDeductable")) {
- res.setUnallocDeductable(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("totalBenefit")) {
- res.setTotalBenefit(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("paymentAdjustment")) {
- res.setPaymentAdjustment(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("paymentAdjustmentReason")) {
- res.setPaymentAdjustmentReason(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("paymentDate")) {
- res.setPaymentDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("paymentAmount")) {
- res.setPaymentAmount(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("paymentRef")) {
- res.setPaymentRef(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reserved")) {
- res.setReserved(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("form")) {
- res.setForm(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseExplanationOfBenefitNoteComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("benefitBalance")) {
- res.getBenefitBalance().add(parseExplanationOfBenefitBenefitBalanceComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.RelatedClaimComponent parseExplanationOfBenefitRelatedClaimComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.RelatedClaimComponent res = new ExplanationOfBenefit.RelatedClaimComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitRelatedClaimComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitRelatedClaimComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.RelatedClaimComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "claim")) {
- res.setClaim(parseType("claim", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relationship")) {
- res.setRelationship(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reference")) {
- res.setReference(parseIdentifier(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.PayeeComponent parseExplanationOfBenefitPayeeComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.PayeeComponent res = new ExplanationOfBenefit.PayeeComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitPayeeComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitPayeeComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.PayeeComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "party")) {
- res.setParty(parseType("party", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.InformationComponent parseExplanationOfBenefitInformationComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.InformationComponent res = new ExplanationOfBenefit.InformationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitInformationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitInformationComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.InformationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "timing")) {
- res.setTiming(parseType("timing", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.DiagnosisComponent parseExplanationOfBenefitDiagnosisComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.DiagnosisComponent res = new ExplanationOfBenefit.DiagnosisComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitDiagnosisComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitDiagnosisComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.DiagnosisComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("diagnosis")) {
- res.setDiagnosis(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.ProcedureComponent parseExplanationOfBenefitProcedureComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.ProcedureComponent res = new ExplanationOfBenefit.ProcedureComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitProcedureComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitProcedureComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.ProcedureComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "procedure")) {
- res.setProcedure(parseType("procedure", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.CoverageComponent parseExplanationOfBenefitCoverageComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.CoverageComponent res = new ExplanationOfBenefit.CoverageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitCoverageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitCoverageComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.CoverageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "coverage")) {
- res.setCoverage(parseType("coverage", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("preAuthRef")) {
- res.getPreAuthRef().add(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.ItemComponent parseExplanationOfBenefitItemComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.ItemComponent res = new ExplanationOfBenefit.ItemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitItemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitItemComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.ItemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("careTeam")) {
- res.getCareTeam().add(parseExplanationOfBenefitCareTeamComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("diagnosisLinkId")) {
- res.getDiagnosisLinkId().add(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("service")) {
- res.setService(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceModifier")) {
- res.getServiceModifier().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("modifier")) {
- res.getModifier().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("programCode")) {
- res.getProgramCode().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "serviced")) {
- res.setServiced(parseType("serviced", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("place")) {
- res.setPlace(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unitPrice")) {
- res.setUnitPrice(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("factor")) {
- res.setFactorElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("points")) {
- res.setPointsElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("net")) {
- res.setNet(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("udi")) {
- res.getUdi().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("bodySite")) {
- res.setBodySite(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subSite")) {
- res.getSubSite().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("noteNumber")) {
- res.getNoteNumber().add(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("adjudication")) {
- res.getAdjudication().add(parseExplanationOfBenefitAdjudicationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.getDetail().add(parseExplanationOfBenefitDetailComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prosthesis")) {
- res.setProsthesis(parseExplanationOfBenefitProsthesisComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.CareTeamComponent parseExplanationOfBenefitCareTeamComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.CareTeamComponent res = new ExplanationOfBenefit.CareTeamComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitCareTeamComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitCareTeamComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.CareTeamComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "provider")) {
- res.setProvider(parseType("provider", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("responsible")) {
- res.setResponsibleElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.setRole(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("qualification")) {
- res.setQualification(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.AdjudicationComponent parseExplanationOfBenefitAdjudicationComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.AdjudicationComponent res = new ExplanationOfBenefit.AdjudicationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitAdjudicationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitAdjudicationComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.AdjudicationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("amount")) {
- res.setAmount(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseDecimal(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.DetailComponent parseExplanationOfBenefitDetailComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.DetailComponent res = new ExplanationOfBenefit.DetailComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitDetailComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitDetailComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.DetailComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("service")) {
- res.setService(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("programCode")) {
- res.getProgramCode().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unitPrice")) {
- res.setUnitPrice(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("factor")) {
- res.setFactorElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("points")) {
- res.setPointsElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("net")) {
- res.setNet(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("udi")) {
- res.getUdi().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("adjudication")) {
- res.getAdjudication().add(parseExplanationOfBenefitAdjudicationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subDetail")) {
- res.getSubDetail().add(parseExplanationOfBenefitSubDetailComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.SubDetailComponent parseExplanationOfBenefitSubDetailComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.SubDetailComponent res = new ExplanationOfBenefit.SubDetailComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitSubDetailComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitSubDetailComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.SubDetailComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("service")) {
- res.setService(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("programCode")) {
- res.getProgramCode().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unitPrice")) {
- res.setUnitPrice(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("factor")) {
- res.setFactorElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("points")) {
- res.setPointsElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("net")) {
- res.setNet(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("udi")) {
- res.getUdi().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("adjudication")) {
- res.getAdjudication().add(parseExplanationOfBenefitAdjudicationComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.ProsthesisComponent parseExplanationOfBenefitProsthesisComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.ProsthesisComponent res = new ExplanationOfBenefit.ProsthesisComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitProsthesisComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitProsthesisComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.ProsthesisComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("initial")) {
- res.setInitialElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priorDate")) {
- res.setPriorDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priorMaterial")) {
- res.setPriorMaterial(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.AddedItemComponent parseExplanationOfBenefitAddedItemComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.AddedItemComponent res = new ExplanationOfBenefit.AddedItemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitAddedItemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitAddedItemComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.AddedItemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequenceLinkId")) {
- res.getSequenceLinkId().add(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("service")) {
- res.setService(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fee")) {
- res.setFee(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("noteNumberLinkId")) {
- res.getNoteNumberLinkId().add(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("adjudication")) {
- res.getAdjudication().add(parseExplanationOfBenefitAdjudicationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.getDetail().add(parseExplanationOfBenefitAddedItemsDetailComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.AddedItemsDetailComponent parseExplanationOfBenefitAddedItemsDetailComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.AddedItemsDetailComponent res = new ExplanationOfBenefit.AddedItemsDetailComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitAddedItemsDetailComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitAddedItemsDetailComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.AddedItemsDetailComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("service")) {
- res.setService(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fee")) {
- res.setFee(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("adjudication")) {
- res.getAdjudication().add(parseExplanationOfBenefitAdjudicationComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.NoteComponent parseExplanationOfBenefitNoteComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.NoteComponent res = new ExplanationOfBenefit.NoteComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitNoteComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitNoteComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.NoteComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("number")) {
- res.setNumberElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.BenefitBalanceComponent parseExplanationOfBenefitBenefitBalanceComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.BenefitBalanceComponent res = new ExplanationOfBenefit.BenefitBalanceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitBenefitBalanceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitBenefitBalanceComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.BenefitBalanceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subCategory")) {
- res.setSubCategory(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("network")) {
- res.setNetwork(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("unit")) {
- res.setUnit(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("term")) {
- res.setTerm(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("financial")) {
- res.getFinancial().add(parseExplanationOfBenefitBenefitComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ExplanationOfBenefit.BenefitComponent parseExplanationOfBenefitBenefitComponent(XmlPullParser xpp, ExplanationOfBenefit owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ExplanationOfBenefit.BenefitComponent res = new ExplanationOfBenefit.BenefitComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseExplanationOfBenefitBenefitComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseExplanationOfBenefitBenefitComponentContent(int eventType, XmlPullParser xpp, ExplanationOfBenefit owner, ExplanationOfBenefit.BenefitComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "benefit")) {
- res.setBenefit(parseType("benefit", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "benefitUsed")) {
- res.setBenefitUsed(parseType("benefitUsed", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected FamilyMemberHistory parseFamilyMemberHistory(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- FamilyMemberHistory res = new FamilyMemberHistory();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseFamilyMemberHistoryContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseFamilyMemberHistoryContent(int eventType, XmlPullParser xpp, FamilyMemberHistory res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, FamilyMemberHistory.FamilyHistoryStatus.NULL, new FamilyMemberHistory.FamilyHistoryStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relationship")) {
- res.setRelationship(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("gender")) {
- res.setGenderElement(parseEnumeration(xpp, Enumerations.AdministrativeGender.NULL, new Enumerations.AdministrativeGenderEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "born")) {
- res.setBorn(parseType("born", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "age")) {
- res.setAge(parseType("age", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "deceased")) {
- res.setDeceased(parseType("deceased", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.setNote(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("condition")) {
- res.getCondition().add(parseFamilyMemberHistoryFamilyMemberHistoryConditionComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected FamilyMemberHistory.FamilyMemberHistoryConditionComponent parseFamilyMemberHistoryFamilyMemberHistoryConditionComponent(XmlPullParser xpp, FamilyMemberHistory owner) throws XmlPullParserException, IOException, FHIRFormatError {
- FamilyMemberHistory.FamilyMemberHistoryConditionComponent res = new FamilyMemberHistory.FamilyMemberHistoryConditionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseFamilyMemberHistoryFamilyMemberHistoryConditionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseFamilyMemberHistoryFamilyMemberHistoryConditionComponentContent(int eventType, XmlPullParser xpp, FamilyMemberHistory owner, FamilyMemberHistory.FamilyMemberHistoryConditionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outcome")) {
- res.setOutcome(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "onset")) {
- res.setOnset(parseType("onset", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.setNote(parseAnnotation(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Flag parseFlag(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Flag res = new Flag();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseFlagContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseFlagContent(int eventType, XmlPullParser xpp, Flag res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Flag.FlagStatus.NULL, new Flag.FlagStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.setAuthor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Goal parseGoal(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Goal res = new Goal();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseGoalContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseGoalContent(int eventType, XmlPullParser xpp, Goal res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "start")) {
- res.setStart(parseType("start", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "target")) {
- res.setTarget(parseType("target", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.getCategory().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Goal.GoalStatus.NULL, new Goal.GoalStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("statusDate")) {
- res.setStatusDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("statusReason")) {
- res.setStatusReason(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("expressedBy")) {
- res.setExpressedBy(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priority")) {
- res.setPriority(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("addresses")) {
- res.getAddresses().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outcome")) {
- res.getOutcome().add(parseGoalGoalOutcomeComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Goal.GoalOutcomeComponent parseGoalGoalOutcomeComponent(XmlPullParser xpp, Goal owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Goal.GoalOutcomeComponent res = new Goal.GoalOutcomeComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseGoalGoalOutcomeComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseGoalGoalOutcomeComponentContent(int eventType, XmlPullParser xpp, Goal owner, Goal.GoalOutcomeComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "result")) {
- res.setResult(parseType("result", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Group parseGroup(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Group res = new Group();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseGroupContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseGroupContent(int eventType, XmlPullParser xpp, Group res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Group.GroupType.NULL, new Group.GroupTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actual")) {
- res.setActualElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("active")) {
- res.setActiveElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantityElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("characteristic")) {
- res.getCharacteristic().add(parseGroupGroupCharacteristicComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("member")) {
- res.getMember().add(parseGroupGroupMemberComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Group.GroupCharacteristicComponent parseGroupGroupCharacteristicComponent(XmlPullParser xpp, Group owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Group.GroupCharacteristicComponent res = new Group.GroupCharacteristicComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseGroupGroupCharacteristicComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseGroupGroupCharacteristicComponentContent(int eventType, XmlPullParser xpp, Group owner, Group.GroupCharacteristicComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("exclude")) {
- res.setExcludeElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Group.GroupMemberComponent parseGroupGroupMemberComponent(XmlPullParser xpp, Group owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Group.GroupMemberComponent res = new Group.GroupMemberComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseGroupGroupMemberComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseGroupGroupMemberComponentContent(int eventType, XmlPullParser xpp, Group owner, Group.GroupMemberComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("entity")) {
- res.setEntity(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("inactive")) {
- res.setInactiveElement(parseBoolean(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected GuidanceResponse parseGuidanceResponse(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- GuidanceResponse res = new GuidanceResponse();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseGuidanceResponseContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseGuidanceResponseContent(int eventType, XmlPullParser xpp, GuidanceResponse res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requestId")) {
- res.setRequestIdElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("module")) {
- res.setModule(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, GuidanceResponse.GuidanceResponseStatus.NULL, new GuidanceResponse.GuidanceResponseStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("evaluationMessage")) {
- res.getEvaluationMessage().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outputParameters")) {
- res.setOutputParameters(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseGuidanceResponseGuidanceResponseActionComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dataRequirement")) {
- res.getDataRequirement().add(parseDataRequirement(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected GuidanceResponse.GuidanceResponseActionComponent parseGuidanceResponseGuidanceResponseActionComponent(XmlPullParser xpp, GuidanceResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- GuidanceResponse.GuidanceResponseActionComponent res = new GuidanceResponse.GuidanceResponseActionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseGuidanceResponseGuidanceResponseActionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseGuidanceResponseGuidanceResponseActionComponentContent(int eventType, XmlPullParser xpp, GuidanceResponse owner, GuidanceResponse.GuidanceResponseActionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actionIdentifier")) {
- res.setActionIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("label")) {
- res.setLabelElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("title")) {
- res.setTitleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("textEquivalent")) {
- res.setTextEquivalentElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("concept")) {
- res.getConcept().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supportingEvidence")) {
- res.getSupportingEvidence().add(parseAttachment(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relatedAction")) {
- res.setRelatedAction(parseGuidanceResponseGuidanceResponseActionRelatedActionComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.getDocumentation().add(parseAttachment(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("participant")) {
- res.getParticipant().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("behavior")) {
- res.getBehavior().add(parseGuidanceResponseGuidanceResponseActionBehaviorComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.setResource(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseGuidanceResponseGuidanceResponseActionComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected GuidanceResponse.GuidanceResponseActionRelatedActionComponent parseGuidanceResponseGuidanceResponseActionRelatedActionComponent(XmlPullParser xpp, GuidanceResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- GuidanceResponse.GuidanceResponseActionRelatedActionComponent res = new GuidanceResponse.GuidanceResponseActionRelatedActionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseGuidanceResponseGuidanceResponseActionRelatedActionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseGuidanceResponseGuidanceResponseActionRelatedActionComponentContent(int eventType, XmlPullParser xpp, GuidanceResponse owner, GuidanceResponse.GuidanceResponseActionRelatedActionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actionIdentifier")) {
- res.setActionIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relationship")) {
- res.setRelationshipElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "offset")) {
- res.setOffset(parseType("offset", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("anchor")) {
- res.setAnchorElement(parseCode(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected GuidanceResponse.GuidanceResponseActionBehaviorComponent parseGuidanceResponseGuidanceResponseActionBehaviorComponent(XmlPullParser xpp, GuidanceResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- GuidanceResponse.GuidanceResponseActionBehaviorComponent res = new GuidanceResponse.GuidanceResponseActionBehaviorComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseGuidanceResponseGuidanceResponseActionBehaviorComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseGuidanceResponseGuidanceResponseActionBehaviorComponentContent(int eventType, XmlPullParser xpp, GuidanceResponse owner, GuidanceResponse.GuidanceResponseActionBehaviorComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValue(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected HealthcareService parseHealthcareService(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- HealthcareService res = new HealthcareService();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseHealthcareServiceContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseHealthcareServiceContent(int eventType, XmlPullParser xpp, HealthcareService res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("providedBy")) {
- res.setProvidedBy(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceCategory")) {
- res.setServiceCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceType")) {
- res.getServiceType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specialty")) {
- res.getSpecialty().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.getLocation().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceName")) {
- res.setServiceNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comment")) {
- res.setCommentElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("extraDetails")) {
- res.setExtraDetailsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("photo")) {
- res.setPhoto(parseAttachment(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("coverageArea")) {
- res.getCoverageArea().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceProvisionCode")) {
- res.getServiceProvisionCode().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("eligibility")) {
- res.setEligibility(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("eligibilityNote")) {
- res.setEligibilityNoteElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("programName")) {
- res.getProgramName().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("characteristic")) {
- res.getCharacteristic().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("referralMethod")) {
- res.getReferralMethod().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publicKey")) {
- res.setPublicKeyElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("appointmentRequired")) {
- res.setAppointmentRequiredElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("availableTime")) {
- res.getAvailableTime().add(parseHealthcareServiceHealthcareServiceAvailableTimeComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("notAvailable")) {
- res.getNotAvailable().add(parseHealthcareServiceHealthcareServiceNotAvailableComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("availabilityExceptions")) {
- res.setAvailabilityExceptionsElement(parseString(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected HealthcareService.HealthcareServiceAvailableTimeComponent parseHealthcareServiceHealthcareServiceAvailableTimeComponent(XmlPullParser xpp, HealthcareService owner) throws XmlPullParserException, IOException, FHIRFormatError {
- HealthcareService.HealthcareServiceAvailableTimeComponent res = new HealthcareService.HealthcareServiceAvailableTimeComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseHealthcareServiceHealthcareServiceAvailableTimeComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseHealthcareServiceHealthcareServiceAvailableTimeComponentContent(int eventType, XmlPullParser xpp, HealthcareService owner, HealthcareService.HealthcareServiceAvailableTimeComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("daysOfWeek")) {
- res.getDaysOfWeek().add(parseEnumeration(xpp, HealthcareService.DaysOfWeek.NULL, new HealthcareService.DaysOfWeekEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("allDay")) {
- res.setAllDayElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("availableStartTime")) {
- res.setAvailableStartTimeElement(parseTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("availableEndTime")) {
- res.setAvailableEndTimeElement(parseTime(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected HealthcareService.HealthcareServiceNotAvailableComponent parseHealthcareServiceHealthcareServiceNotAvailableComponent(XmlPullParser xpp, HealthcareService owner) throws XmlPullParserException, IOException, FHIRFormatError {
- HealthcareService.HealthcareServiceNotAvailableComponent res = new HealthcareService.HealthcareServiceNotAvailableComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseHealthcareServiceHealthcareServiceNotAvailableComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseHealthcareServiceHealthcareServiceNotAvailableComponentContent(int eventType, XmlPullParser xpp, HealthcareService owner, HealthcareService.HealthcareServiceNotAvailableComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("during")) {
- res.setDuring(parsePeriod(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
-
-
- protected ImagingStudy parseImagingStudy(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ImagingStudy res = new ImagingStudy();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImagingStudyContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImagingStudyContent(int eventType, XmlPullParser xpp, ImagingStudy res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("uid")) {
- res.setUidElement(parseOid(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("accession")) {
- res.setAccession(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("availability")) {
- res.setAvailabilityElement(parseEnumeration(xpp, ImagingStudy.InstanceAvailability.NULL, new ImagingStudy.InstanceAvailabilityEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("modalityList")) {
- res.getModalityList().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("started")) {
- res.setStartedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("order")) {
- res.getOrder().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("referrer")) {
- res.setReferrer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("interpreter")) {
- res.setInterpreter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("numberOfSeries")) {
- res.setNumberOfSeriesElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("numberOfInstances")) {
- res.setNumberOfInstancesElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("procedure")) {
- res.getProcedure().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("series")) {
- res.getSeries().add(parseImagingStudyImagingStudySeriesComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImagingStudy.ImagingStudySeriesComponent parseImagingStudyImagingStudySeriesComponent(XmlPullParser xpp, ImagingStudy owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ImagingStudy.ImagingStudySeriesComponent res = new ImagingStudy.ImagingStudySeriesComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImagingStudyImagingStudySeriesComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImagingStudyImagingStudySeriesComponentContent(int eventType, XmlPullParser xpp, ImagingStudy owner, ImagingStudy.ImagingStudySeriesComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("uid")) {
- res.setUidElement(parseOid(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("number")) {
- res.setNumberElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("modality")) {
- res.setModality(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("numberOfInstances")) {
- res.setNumberOfInstancesElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("availability")) {
- res.setAvailabilityElement(parseEnumeration(xpp, ImagingStudy.InstanceAvailability.NULL, new ImagingStudy.InstanceAvailabilityEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("bodySite")) {
- res.setBodySite(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("laterality")) {
- res.setLaterality(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("started")) {
- res.setStartedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("instance")) {
- res.getInstance().add(parseImagingStudyImagingStudySeriesInstanceComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImagingStudy.ImagingStudySeriesInstanceComponent parseImagingStudyImagingStudySeriesInstanceComponent(XmlPullParser xpp, ImagingStudy owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ImagingStudy.ImagingStudySeriesInstanceComponent res = new ImagingStudy.ImagingStudySeriesInstanceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImagingStudyImagingStudySeriesInstanceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImagingStudyImagingStudySeriesInstanceComponentContent(int eventType, XmlPullParser xpp, ImagingStudy owner, ImagingStudy.ImagingStudySeriesInstanceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("uid")) {
- res.setUidElement(parseOid(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("number")) {
- res.setNumberElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sopClass")) {
- res.setSopClassElement(parseOid(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("title")) {
- res.setTitleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("content")) {
- res.getContent().add(parseAttachment(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Immunization parseImmunization(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Immunization res = new Immunization();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImmunizationContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImmunizationContent(int eventType, XmlPullParser xpp, Immunization res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("vaccineCode")) {
- res.setVaccineCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("wasNotGiven")) {
- res.setWasNotGivenElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reported")) {
- res.setReportedElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("performer")) {
- res.setPerformer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requester")) {
- res.setRequester(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("manufacturer")) {
- res.setManufacturer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.setLocation(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lotNumber")) {
- res.setLotNumberElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("expirationDate")) {
- res.setExpirationDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("site")) {
- res.setSite(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("route")) {
- res.setRoute(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("doseQuantity")) {
- res.setDoseQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("explanation")) {
- res.setExplanation(parseImmunizationImmunizationExplanationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reaction")) {
- res.getReaction().add(parseImmunizationImmunizationReactionComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("vaccinationProtocol")) {
- res.getVaccinationProtocol().add(parseImmunizationImmunizationVaccinationProtocolComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Immunization.ImmunizationExplanationComponent parseImmunizationImmunizationExplanationComponent(XmlPullParser xpp, Immunization owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Immunization.ImmunizationExplanationComponent res = new Immunization.ImmunizationExplanationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImmunizationImmunizationExplanationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImmunizationImmunizationExplanationComponentContent(int eventType, XmlPullParser xpp, Immunization owner, Immunization.ImmunizationExplanationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.getReason().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reasonNotGiven")) {
- res.getReasonNotGiven().add(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Immunization.ImmunizationReactionComponent parseImmunizationImmunizationReactionComponent(XmlPullParser xpp, Immunization owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Immunization.ImmunizationReactionComponent res = new Immunization.ImmunizationReactionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImmunizationImmunizationReactionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImmunizationImmunizationReactionComponentContent(int eventType, XmlPullParser xpp, Immunization owner, Immunization.ImmunizationReactionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.setDetail(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reported")) {
- res.setReportedElement(parseBoolean(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Immunization.ImmunizationVaccinationProtocolComponent parseImmunizationImmunizationVaccinationProtocolComponent(XmlPullParser xpp, Immunization owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Immunization.ImmunizationVaccinationProtocolComponent res = new Immunization.ImmunizationVaccinationProtocolComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImmunizationImmunizationVaccinationProtocolComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImmunizationImmunizationVaccinationProtocolComponentContent(int eventType, XmlPullParser xpp, Immunization owner, Immunization.ImmunizationVaccinationProtocolComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("doseSequence")) {
- res.setDoseSequenceElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("authority")) {
- res.setAuthority(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("series")) {
- res.setSeriesElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("seriesDoses")) {
- res.setSeriesDosesElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("targetDisease")) {
- res.getTargetDisease().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("doseStatus")) {
- res.setDoseStatus(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("doseStatusReason")) {
- res.setDoseStatusReason(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImmunizationRecommendation parseImmunizationRecommendation(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ImmunizationRecommendation res = new ImmunizationRecommendation();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImmunizationRecommendationContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImmunizationRecommendationContent(int eventType, XmlPullParser xpp, ImmunizationRecommendation res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recommendation")) {
- res.getRecommendation().add(parseImmunizationRecommendationImmunizationRecommendationRecommendationComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent parseImmunizationRecommendationImmunizationRecommendationRecommendationComponent(XmlPullParser xpp, ImmunizationRecommendation owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent res = new ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImmunizationRecommendationImmunizationRecommendationRecommendationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImmunizationRecommendationImmunizationRecommendationRecommendationComponentContent(int eventType, XmlPullParser xpp, ImmunizationRecommendation owner, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("vaccineCode")) {
- res.setVaccineCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("doseNumber")) {
- res.setDoseNumberElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("forecastStatus")) {
- res.setForecastStatus(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateCriterion")) {
- res.getDateCriterion().add(parseImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("protocol")) {
- res.setProtocol(parseImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supportingImmunization")) {
- res.getSupportingImmunization().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supportingPatientInformation")) {
- res.getSupportingPatientInformation().add(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent parseImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(XmlPullParser xpp, ImmunizationRecommendation owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent res = new ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponentContent(int eventType, XmlPullParser xpp, ImmunizationRecommendation owner, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseDateTime(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent parseImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(XmlPullParser xpp, ImmunizationRecommendation owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent res = new ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponentContent(int eventType, XmlPullParser xpp, ImmunizationRecommendation owner, ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("doseSequence")) {
- res.setDoseSequenceElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("authority")) {
- res.setAuthority(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("series")) {
- res.setSeriesElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImplementationGuide parseImplementationGuide(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ImplementationGuide res = new ImplementationGuide();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImplementationGuideContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImplementationGuideContent(int eventType, XmlPullParser xpp, ImplementationGuide res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseImplementationGuideImplementationGuideContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("copyright")) {
- res.setCopyrightElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fhirVersion")) {
- res.setFhirVersionElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dependency")) {
- res.getDependency().add(parseImplementationGuideImplementationGuideDependencyComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("package")) {
- res.getPackage().add(parseImplementationGuideImplementationGuidePackageComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("global")) {
- res.getGlobal().add(parseImplementationGuideImplementationGuideGlobalComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("binary")) {
- res.getBinary().add(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("page")) {
- res.setPage(parseImplementationGuideImplementationGuidePageComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImplementationGuide.ImplementationGuideContactComponent parseImplementationGuideImplementationGuideContactComponent(XmlPullParser xpp, ImplementationGuide owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ImplementationGuide.ImplementationGuideContactComponent res = new ImplementationGuide.ImplementationGuideContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImplementationGuideImplementationGuideContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImplementationGuideImplementationGuideContactComponentContent(int eventType, XmlPullParser xpp, ImplementationGuide owner, ImplementationGuide.ImplementationGuideContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImplementationGuide.ImplementationGuideDependencyComponent parseImplementationGuideImplementationGuideDependencyComponent(XmlPullParser xpp, ImplementationGuide owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ImplementationGuide.ImplementationGuideDependencyComponent res = new ImplementationGuide.ImplementationGuideDependencyComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImplementationGuideImplementationGuideDependencyComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImplementationGuideImplementationGuideDependencyComponentContent(int eventType, XmlPullParser xpp, ImplementationGuide owner, ImplementationGuide.ImplementationGuideDependencyComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, ImplementationGuide.GuideDependencyType.NULL, new ImplementationGuide.GuideDependencyTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("uri")) {
- res.setUriElement(parseUri(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImplementationGuide.ImplementationGuidePackageComponent parseImplementationGuideImplementationGuidePackageComponent(XmlPullParser xpp, ImplementationGuide owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ImplementationGuide.ImplementationGuidePackageComponent res = new ImplementationGuide.ImplementationGuidePackageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImplementationGuideImplementationGuidePackageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImplementationGuideImplementationGuidePackageComponentContent(int eventType, XmlPullParser xpp, ImplementationGuide owner, ImplementationGuide.ImplementationGuidePackageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.getResource().add(parseImplementationGuideImplementationGuidePackageResourceComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImplementationGuide.ImplementationGuidePackageResourceComponent parseImplementationGuideImplementationGuidePackageResourceComponent(XmlPullParser xpp, ImplementationGuide owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ImplementationGuide.ImplementationGuidePackageResourceComponent res = new ImplementationGuide.ImplementationGuidePackageResourceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImplementationGuideImplementationGuidePackageResourceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImplementationGuideImplementationGuidePackageResourceComponentContent(int eventType, XmlPullParser xpp, ImplementationGuide owner, ImplementationGuide.ImplementationGuidePackageResourceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("example")) {
- res.setExampleElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("acronym")) {
- res.setAcronymElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "source")) {
- res.setSource(parseType("source", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("exampleFor")) {
- res.setExampleFor(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImplementationGuide.ImplementationGuideGlobalComponent parseImplementationGuideImplementationGuideGlobalComponent(XmlPullParser xpp, ImplementationGuide owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ImplementationGuide.ImplementationGuideGlobalComponent res = new ImplementationGuide.ImplementationGuideGlobalComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImplementationGuideImplementationGuideGlobalComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImplementationGuideImplementationGuideGlobalComponentContent(int eventType, XmlPullParser xpp, ImplementationGuide owner, ImplementationGuide.ImplementationGuideGlobalComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.setProfile(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ImplementationGuide.ImplementationGuidePageComponent parseImplementationGuideImplementationGuidePageComponent(XmlPullParser xpp, ImplementationGuide owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ImplementationGuide.ImplementationGuidePageComponent res = new ImplementationGuide.ImplementationGuidePageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseImplementationGuideImplementationGuidePageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseImplementationGuideImplementationGuidePageComponentContent(int eventType, XmlPullParser xpp, ImplementationGuide owner, ImplementationGuide.ImplementationGuidePageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("source")) {
- res.setSourceElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("kind")) {
- res.setKindElement(parseEnumeration(xpp, ImplementationGuide.GuidePageKind.NULL, new ImplementationGuide.GuidePageKindEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("package")) {
- res.getPackage().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("format")) {
- res.setFormatElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("page")) {
- res.getPage().add(parseImplementationGuideImplementationGuidePageComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Library parseLibrary(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Library res = new Library();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseLibraryContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseLibraryContent(int eventType, XmlPullParser xpp, Library res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("moduleMetadata")) {
- res.setModuleMetadata(parseModuleMetadata(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("model")) {
- res.getModel().add(parseLibraryLibraryModelComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("library")) {
- res.getLibrary().add(parseLibraryLibraryLibraryComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("codeSystem")) {
- res.getCodeSystem().add(parseLibraryLibraryCodeSystemComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("valueSet")) {
- res.getValueSet().add(parseLibraryLibraryValueSetComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parameter")) {
- res.getParameter().add(parseParameterDefinition(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dataRequirement")) {
- res.getDataRequirement().add(parseDataRequirement(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("document")) {
- res.setDocument(parseAttachment(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Library.LibraryModelComponent parseLibraryLibraryModelComponent(XmlPullParser xpp, Library owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Library.LibraryModelComponent res = new Library.LibraryModelComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseLibraryLibraryModelComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseLibraryLibraryModelComponentContent(int eventType, XmlPullParser xpp, Library owner, Library.LibraryModelComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifierElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Library.LibraryLibraryComponent parseLibraryLibraryLibraryComponent(XmlPullParser xpp, Library owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Library.LibraryLibraryComponent res = new Library.LibraryLibraryComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseLibraryLibraryLibraryComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseLibraryLibraryLibraryComponentContent(int eventType, XmlPullParser xpp, Library owner, Library.LibraryLibraryComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifierElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "document")) {
- res.setDocument(parseType("document", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Library.LibraryCodeSystemComponent parseLibraryLibraryCodeSystemComponent(XmlPullParser xpp, Library owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Library.LibraryCodeSystemComponent res = new Library.LibraryCodeSystemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseLibraryLibraryCodeSystemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseLibraryLibraryCodeSystemComponentContent(int eventType, XmlPullParser xpp, Library owner, Library.LibraryCodeSystemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifierElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Library.LibraryValueSetComponent parseLibraryLibraryValueSetComponent(XmlPullParser xpp, Library owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Library.LibraryValueSetComponent res = new Library.LibraryValueSetComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseLibraryLibraryValueSetComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseLibraryLibraryValueSetComponentContent(int eventType, XmlPullParser xpp, Library owner, Library.LibraryValueSetComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifierElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("codeSystem")) {
- res.getCodeSystem().add(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Linkage parseLinkage(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Linkage res = new Linkage();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseLinkageContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseLinkageContent(int eventType, XmlPullParser xpp, Linkage res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.setAuthor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseLinkageLinkageItemComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Linkage.LinkageItemComponent parseLinkageLinkageItemComponent(XmlPullParser xpp, Linkage owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Linkage.LinkageItemComponent res = new Linkage.LinkageItemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseLinkageLinkageItemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseLinkageLinkageItemComponentContent(int eventType, XmlPullParser xpp, Linkage owner, Linkage.LinkageItemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Linkage.LinkageType.NULL, new Linkage.LinkageTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.setResource(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ListResource parseListResource(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ListResource res = new ListResource();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseListResourceContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseListResourceContent(int eventType, XmlPullParser xpp, ListResource res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, ListResource.ListStatus.NULL, new ListResource.ListStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mode")) {
- res.setModeElement(parseEnumeration(xpp, ListResource.ListMode.NULL, new ListResource.ListModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("title")) {
- res.setTitleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("source")) {
- res.setSource(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("orderedBy")) {
- res.setOrderedBy(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("entry")) {
- res.getEntry().add(parseListResourceListEntryComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("emptyReason")) {
- res.setEmptyReason(parseCodeableConcept(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ListResource.ListEntryComponent parseListResourceListEntryComponent(XmlPullParser xpp, ListResource owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ListResource.ListEntryComponent res = new ListResource.ListEntryComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseListResourceListEntryComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseListResourceListEntryComponentContent(int eventType, XmlPullParser xpp, ListResource owner, ListResource.ListEntryComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("flag")) {
- res.setFlag(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("deleted")) {
- res.setDeletedElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.setItem(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Location parseLocation(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Location res = new Location();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseLocationContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseLocationContent(int eventType, XmlPullParser xpp, Location res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Location.LocationStatus.NULL, new Location.LocationStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mode")) {
- res.setModeElement(parseEnumeration(xpp, Location.LocationMode.NULL, new Location.LocationModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("address")) {
- res.setAddress(parseAddress(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("physicalType")) {
- res.setPhysicalType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("position")) {
- res.setPosition(parseLocationLocationPositionComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("managingOrganization")) {
- res.setManagingOrganization(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("partOf")) {
- res.setPartOf(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Location.LocationPositionComponent parseLocationLocationPositionComponent(XmlPullParser xpp, Location owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Location.LocationPositionComponent res = new Location.LocationPositionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseLocationLocationPositionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseLocationLocationPositionComponentContent(int eventType, XmlPullParser xpp, Location owner, Location.LocationPositionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("longitude")) {
- res.setLongitudeElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("latitude")) {
- res.setLatitudeElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("altitude")) {
- res.setAltitudeElement(parseDecimal(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Measure parseMeasure(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Measure res = new Measure();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureContent(int eventType, XmlPullParser xpp, Measure res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("moduleMetadata")) {
- res.setModuleMetadata(parseModuleMetadata(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("library")) {
- res.getLibrary().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("disclaimer")) {
- res.setDisclaimerElement(parseMarkdown(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("scoring")) {
- res.setScoringElement(parseEnumeration(xpp, Measure.MeasureScoring.NULL, new Measure.MeasureScoringEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseEnumeration(xpp, Measure.MeasureType.NULL, new Measure.MeasureTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("riskAdjustment")) {
- res.setRiskAdjustmentElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rateAggregation")) {
- res.setRateAggregationElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rationale")) {
- res.setRationaleElement(parseMarkdown(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("clinicalRecommendationStatement")) {
- res.setClinicalRecommendationStatementElement(parseMarkdown(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("improvementNotation")) {
- res.setImprovementNotationElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("definition")) {
- res.setDefinitionElement(parseMarkdown(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("guidance")) {
- res.setGuidanceElement(parseMarkdown(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("set")) {
- res.setSetElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("group")) {
- res.getGroup().add(parseMeasureMeasureGroupComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supplementalData")) {
- res.getSupplementalData().add(parseMeasureMeasureSupplementalDataComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Measure.MeasureGroupComponent parseMeasureMeasureGroupComponent(XmlPullParser xpp, Measure owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Measure.MeasureGroupComponent res = new Measure.MeasureGroupComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureMeasureGroupComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureMeasureGroupComponentContent(int eventType, XmlPullParser xpp, Measure owner, Measure.MeasureGroupComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("population")) {
- res.getPopulation().add(parseMeasureMeasureGroupPopulationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("stratifier")) {
- res.getStratifier().add(parseMeasureMeasureGroupStratifierComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Measure.MeasureGroupPopulationComponent parseMeasureMeasureGroupPopulationComponent(XmlPullParser xpp, Measure owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Measure.MeasureGroupPopulationComponent res = new Measure.MeasureGroupPopulationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureMeasureGroupPopulationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureMeasureGroupPopulationComponentContent(int eventType, XmlPullParser xpp, Measure owner, Measure.MeasureGroupPopulationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Measure.MeasurePopulationType.NULL, new Measure.MeasurePopulationTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("criteria")) {
- res.setCriteriaElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Measure.MeasureGroupStratifierComponent parseMeasureMeasureGroupStratifierComponent(XmlPullParser xpp, Measure owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Measure.MeasureGroupStratifierComponent res = new Measure.MeasureGroupStratifierComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureMeasureGroupStratifierComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureMeasureGroupStratifierComponentContent(int eventType, XmlPullParser xpp, Measure owner, Measure.MeasureGroupStratifierComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("criteria")) {
- res.setCriteriaElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("path")) {
- res.setPathElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Measure.MeasureSupplementalDataComponent parseMeasureMeasureSupplementalDataComponent(XmlPullParser xpp, Measure owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Measure.MeasureSupplementalDataComponent res = new Measure.MeasureSupplementalDataComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureMeasureSupplementalDataComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureMeasureSupplementalDataComponentContent(int eventType, XmlPullParser xpp, Measure owner, Measure.MeasureSupplementalDataComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("usage")) {
- res.getUsage().add(parseEnumeration(xpp, Measure.MeasureDataUsage.NULL, new Measure.MeasureDataUsageEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("criteria")) {
- res.setCriteriaElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("path")) {
- res.setPathElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MeasureReport parseMeasureReport(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- MeasureReport res = new MeasureReport();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureReportContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureReportContent(int eventType, XmlPullParser xpp, MeasureReport res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("measure")) {
- res.setMeasure(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, MeasureReport.MeasureReportType.NULL, new MeasureReport.MeasureReportTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, MeasureReport.MeasureReportStatus.NULL, new MeasureReport.MeasureReportStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reportingOrganization")) {
- res.setReportingOrganization(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("group")) {
- res.getGroup().add(parseMeasureReportMeasureReportGroupComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("evaluatedResources")) {
- res.setEvaluatedResources(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MeasureReport.MeasureReportGroupComponent parseMeasureReportMeasureReportGroupComponent(XmlPullParser xpp, MeasureReport owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MeasureReport.MeasureReportGroupComponent res = new MeasureReport.MeasureReportGroupComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureReportMeasureReportGroupComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureReportMeasureReportGroupComponentContent(int eventType, XmlPullParser xpp, MeasureReport owner, MeasureReport.MeasureReportGroupComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("population")) {
- res.getPopulation().add(parseMeasureReportMeasureReportGroupPopulationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("measureScore")) {
- res.setMeasureScoreElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("stratifier")) {
- res.getStratifier().add(parseMeasureReportMeasureReportGroupStratifierComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supplementalData")) {
- res.getSupplementalData().add(parseMeasureReportMeasureReportGroupSupplementalDataComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MeasureReport.MeasureReportGroupPopulationComponent parseMeasureReportMeasureReportGroupPopulationComponent(XmlPullParser xpp, MeasureReport owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MeasureReport.MeasureReportGroupPopulationComponent res = new MeasureReport.MeasureReportGroupPopulationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureReportMeasureReportGroupPopulationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureReportMeasureReportGroupPopulationComponentContent(int eventType, XmlPullParser xpp, MeasureReport owner, MeasureReport.MeasureReportGroupPopulationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("count")) {
- res.setCountElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patients")) {
- res.setPatients(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MeasureReport.MeasureReportGroupStratifierComponent parseMeasureReportMeasureReportGroupStratifierComponent(XmlPullParser xpp, MeasureReport owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MeasureReport.MeasureReportGroupStratifierComponent res = new MeasureReport.MeasureReportGroupStratifierComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureReportMeasureReportGroupStratifierComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureReportMeasureReportGroupStratifierComponentContent(int eventType, XmlPullParser xpp, MeasureReport owner, MeasureReport.MeasureReportGroupStratifierComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("group")) {
- res.getGroup().add(parseMeasureReportMeasureReportGroupStratifierGroupComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MeasureReport.MeasureReportGroupStratifierGroupComponent parseMeasureReportMeasureReportGroupStratifierGroupComponent(XmlPullParser xpp, MeasureReport owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MeasureReport.MeasureReportGroupStratifierGroupComponent res = new MeasureReport.MeasureReportGroupStratifierGroupComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureReportMeasureReportGroupStratifierGroupComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureReportMeasureReportGroupStratifierGroupComponentContent(int eventType, XmlPullParser xpp, MeasureReport owner, MeasureReport.MeasureReportGroupStratifierGroupComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("population")) {
- res.getPopulation().add(parseMeasureReportMeasureReportGroupStratifierGroupPopulationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("measureScore")) {
- res.setMeasureScoreElement(parseDecimal(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MeasureReport.MeasureReportGroupStratifierGroupPopulationComponent parseMeasureReportMeasureReportGroupStratifierGroupPopulationComponent(XmlPullParser xpp, MeasureReport owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MeasureReport.MeasureReportGroupStratifierGroupPopulationComponent res = new MeasureReport.MeasureReportGroupStratifierGroupPopulationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureReportMeasureReportGroupStratifierGroupPopulationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureReportMeasureReportGroupStratifierGroupPopulationComponentContent(int eventType, XmlPullParser xpp, MeasureReport owner, MeasureReport.MeasureReportGroupStratifierGroupPopulationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("count")) {
- res.setCountElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patients")) {
- res.setPatients(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MeasureReport.MeasureReportGroupSupplementalDataComponent parseMeasureReportMeasureReportGroupSupplementalDataComponent(XmlPullParser xpp, MeasureReport owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MeasureReport.MeasureReportGroupSupplementalDataComponent res = new MeasureReport.MeasureReportGroupSupplementalDataComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureReportMeasureReportGroupSupplementalDataComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureReportMeasureReportGroupSupplementalDataComponentContent(int eventType, XmlPullParser xpp, MeasureReport owner, MeasureReport.MeasureReportGroupSupplementalDataComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("group")) {
- res.getGroup().add(parseMeasureReportMeasureReportGroupSupplementalDataGroupComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MeasureReport.MeasureReportGroupSupplementalDataGroupComponent parseMeasureReportMeasureReportGroupSupplementalDataGroupComponent(XmlPullParser xpp, MeasureReport owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MeasureReport.MeasureReportGroupSupplementalDataGroupComponent res = new MeasureReport.MeasureReportGroupSupplementalDataGroupComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMeasureReportMeasureReportGroupSupplementalDataGroupComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMeasureReportMeasureReportGroupSupplementalDataGroupComponentContent(int eventType, XmlPullParser xpp, MeasureReport owner, MeasureReport.MeasureReportGroupSupplementalDataGroupComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("count")) {
- res.setCountElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patients")) {
- res.setPatients(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Media parseMedia(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Media res = new Media();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMediaContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMediaContent(int eventType, XmlPullParser xpp, Media res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Media.DigitalMediaType.NULL, new Media.DigitalMediaTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subtype")) {
- res.setSubtype(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("view")) {
- res.setView(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("operator")) {
- res.setOperator(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("deviceName")) {
- res.setDeviceNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("height")) {
- res.setHeightElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("width")) {
- res.setWidthElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("frames")) {
- res.setFramesElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("duration")) {
- res.setDurationElement(parseUnsignedInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("content")) {
- res.setContent(parseAttachment(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Medication parseMedication(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Medication res = new Medication();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationContent(int eventType, XmlPullParser xpp, Medication res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("isBrand")) {
- res.setIsBrandElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("manufacturer")) {
- res.setManufacturer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("product")) {
- res.setProduct(parseMedicationMedicationProductComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("package")) {
- res.setPackage(parseMedicationMedicationPackageComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Medication.MedicationProductComponent parseMedicationMedicationProductComponent(XmlPullParser xpp, Medication owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Medication.MedicationProductComponent res = new Medication.MedicationProductComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationMedicationProductComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationMedicationProductComponentContent(int eventType, XmlPullParser xpp, Medication owner, Medication.MedicationProductComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("form")) {
- res.setForm(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ingredient")) {
- res.getIngredient().add(parseMedicationMedicationProductIngredientComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("batch")) {
- res.getBatch().add(parseMedicationMedicationProductBatchComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Medication.MedicationProductIngredientComponent parseMedicationMedicationProductIngredientComponent(XmlPullParser xpp, Medication owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Medication.MedicationProductIngredientComponent res = new Medication.MedicationProductIngredientComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationMedicationProductIngredientComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationMedicationProductIngredientComponentContent(int eventType, XmlPullParser xpp, Medication owner, Medication.MedicationProductIngredientComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "item")) {
- res.setItem(parseType("item", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("amount")) {
- res.setAmount(parseRatio(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Medication.MedicationProductBatchComponent parseMedicationMedicationProductBatchComponent(XmlPullParser xpp, Medication owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Medication.MedicationProductBatchComponent res = new Medication.MedicationProductBatchComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationMedicationProductBatchComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationMedicationProductBatchComponentContent(int eventType, XmlPullParser xpp, Medication owner, Medication.MedicationProductBatchComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lotNumber")) {
- res.setLotNumberElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("expirationDate")) {
- res.setExpirationDateElement(parseDateTime(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Medication.MedicationPackageComponent parseMedicationMedicationPackageComponent(XmlPullParser xpp, Medication owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Medication.MedicationPackageComponent res = new Medication.MedicationPackageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationMedicationPackageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationMedicationPackageComponentContent(int eventType, XmlPullParser xpp, Medication owner, Medication.MedicationPackageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("container")) {
- res.setContainer(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("content")) {
- res.getContent().add(parseMedicationMedicationPackageContentComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Medication.MedicationPackageContentComponent parseMedicationMedicationPackageContentComponent(XmlPullParser xpp, Medication owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Medication.MedicationPackageContentComponent res = new Medication.MedicationPackageContentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationMedicationPackageContentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationMedicationPackageContentComponentContent(int eventType, XmlPullParser xpp, Medication owner, Medication.MedicationPackageContentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "item")) {
- res.setItem(parseType("item", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("amount")) {
- res.setAmount(parseSimpleQuantity(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationAdministration parseMedicationAdministration(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationAdministration res = new MedicationAdministration();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationAdministrationContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationAdministrationContent(int eventType, XmlPullParser xpp, MedicationAdministration res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, MedicationAdministration.MedicationAdministrationStatus.NULL, new MedicationAdministration.MedicationAdministrationStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "medication")) {
- res.setMedication(parseType("medication", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "effectiveTime")) {
- res.setEffectiveTime(parseType("effectiveTime", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("performer")) {
- res.setPerformer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prescription")) {
- res.setPrescription(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("wasNotGiven")) {
- res.setWasNotGivenElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reasonNotGiven")) {
- res.getReasonNotGiven().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reasonGiven")) {
- res.getReasonGiven().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("device")) {
- res.getDevice().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dosage")) {
- res.setDosage(parseMedicationAdministrationMedicationAdministrationDosageComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("eventHistory")) {
- res.getEventHistory().add(parseMedicationAdministrationMedicationAdministrationEventHistoryComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationAdministration.MedicationAdministrationDosageComponent parseMedicationAdministrationMedicationAdministrationDosageComponent(XmlPullParser xpp, MedicationAdministration owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationAdministration.MedicationAdministrationDosageComponent res = new MedicationAdministration.MedicationAdministrationDosageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationAdministrationMedicationAdministrationDosageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationAdministrationMedicationAdministrationDosageComponentContent(int eventType, XmlPullParser xpp, MedicationAdministration owner, MedicationAdministration.MedicationAdministrationDosageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "site")) {
- res.setSite(parseType("site", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("route")) {
- res.setRoute(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("method")) {
- res.setMethod(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dose")) {
- res.setDose(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "rate")) {
- res.setRate(parseType("rate", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationAdministration.MedicationAdministrationEventHistoryComponent parseMedicationAdministrationMedicationAdministrationEventHistoryComponent(XmlPullParser xpp, MedicationAdministration owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationAdministration.MedicationAdministrationEventHistoryComponent res = new MedicationAdministration.MedicationAdministrationEventHistoryComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationAdministrationMedicationAdministrationEventHistoryComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationAdministrationMedicationAdministrationEventHistoryComponentContent(int eventType, XmlPullParser xpp, MedicationAdministration owner, MedicationAdministration.MedicationAdministrationEventHistoryComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, MedicationAdministration.MedicationAdministrationStatus.NULL, new MedicationAdministration.MedicationAdministrationStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.setAction(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateTime")) {
- res.setDateTimeElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationDispense parseMedicationDispense(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationDispense res = new MedicationDispense();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationDispenseContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationDispenseContent(int eventType, XmlPullParser xpp, MedicationDispense res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, MedicationDispense.MedicationDispenseStatus.NULL, new MedicationDispense.MedicationDispenseStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "medication")) {
- res.setMedication(parseType("medication", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dispenser")) {
- res.setDispenser(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("authorizingPrescription")) {
- res.getAuthorizingPrescription().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("daysSupply")) {
- res.setDaysSupply(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("whenPrepared")) {
- res.setWhenPreparedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("whenHandedOver")) {
- res.setWhenHandedOverElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("destination")) {
- res.setDestination(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("receiver")) {
- res.getReceiver().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dosageInstruction")) {
- res.getDosageInstruction().add(parseMedicationDispenseMedicationDispenseDosageInstructionComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("substitution")) {
- res.setSubstitution(parseMedicationDispenseMedicationDispenseSubstitutionComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("eventHistory")) {
- res.getEventHistory().add(parseMedicationDispenseMedicationDispenseEventHistoryComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationDispense.MedicationDispenseDosageInstructionComponent parseMedicationDispenseMedicationDispenseDosageInstructionComponent(XmlPullParser xpp, MedicationDispense owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationDispense.MedicationDispenseDosageInstructionComponent res = new MedicationDispense.MedicationDispenseDosageInstructionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationDispenseMedicationDispenseDosageInstructionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationDispenseMedicationDispenseDosageInstructionComponentContent(int eventType, XmlPullParser xpp, MedicationDispense owner, MedicationDispense.MedicationDispenseDosageInstructionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("additionalInstructions")) {
- res.getAdditionalInstructions().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("timing")) {
- res.setTiming(parseTiming(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "asNeeded")) {
- res.setAsNeeded(parseType("asNeeded", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "site")) {
- res.setSite(parseType("site", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("route")) {
- res.setRoute(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("method")) {
- res.setMethod(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "dose")) {
- res.setDose(parseType("dose", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "rate")) {
- res.setRate(parseType("rate", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("maxDosePerPeriod")) {
- res.setMaxDosePerPeriod(parseRatio(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationDispense.MedicationDispenseSubstitutionComponent parseMedicationDispenseMedicationDispenseSubstitutionComponent(XmlPullParser xpp, MedicationDispense owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationDispense.MedicationDispenseSubstitutionComponent res = new MedicationDispense.MedicationDispenseSubstitutionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationDispenseMedicationDispenseSubstitutionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationDispenseMedicationDispenseSubstitutionComponentContent(int eventType, XmlPullParser xpp, MedicationDispense owner, MedicationDispense.MedicationDispenseSubstitutionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.getReason().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("responsibleParty")) {
- res.getResponsibleParty().add(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationDispense.MedicationDispenseEventHistoryComponent parseMedicationDispenseMedicationDispenseEventHistoryComponent(XmlPullParser xpp, MedicationDispense owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationDispense.MedicationDispenseEventHistoryComponent res = new MedicationDispense.MedicationDispenseEventHistoryComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationDispenseMedicationDispenseEventHistoryComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationDispenseMedicationDispenseEventHistoryComponentContent(int eventType, XmlPullParser xpp, MedicationDispense owner, MedicationDispense.MedicationDispenseEventHistoryComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, MedicationDispense.MedicationDispenseStatus.NULL, new MedicationDispense.MedicationDispenseStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.setAction(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateTime")) {
- res.setDateTimeElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationOrder parseMedicationOrder(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationOrder res = new MedicationOrder();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationOrderContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationOrderContent(int eventType, XmlPullParser xpp, MedicationOrder res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, MedicationOrder.MedicationOrderStatus.NULL, new MedicationOrder.MedicationOrderStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "medication")) {
- res.setMedication(parseType("medication", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateWritten")) {
- res.setDateWrittenElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prescriber")) {
- res.setPrescriber(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reasonCode")) {
- res.getReasonCode().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reasonReference")) {
- res.getReasonReference().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dosageInstruction")) {
- res.getDosageInstruction().add(parseMedicationOrderMedicationOrderDosageInstructionComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dispenseRequest")) {
- res.setDispenseRequest(parseMedicationOrderMedicationOrderDispenseRequestComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("substitution")) {
- res.setSubstitution(parseMedicationOrderMedicationOrderSubstitutionComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priorPrescription")) {
- res.setPriorPrescription(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("eventHistory")) {
- res.getEventHistory().add(parseMedicationOrderMedicationOrderEventHistoryComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationOrder.MedicationOrderDosageInstructionComponent parseMedicationOrderMedicationOrderDosageInstructionComponent(XmlPullParser xpp, MedicationOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationOrder.MedicationOrderDosageInstructionComponent res = new MedicationOrder.MedicationOrderDosageInstructionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationOrderMedicationOrderDosageInstructionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationOrderMedicationOrderDosageInstructionComponentContent(int eventType, XmlPullParser xpp, MedicationOrder owner, MedicationOrder.MedicationOrderDosageInstructionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("additionalInstructions")) {
- res.getAdditionalInstructions().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("timing")) {
- res.setTiming(parseTiming(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "asNeeded")) {
- res.setAsNeeded(parseType("asNeeded", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "site")) {
- res.setSite(parseType("site", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("route")) {
- res.setRoute(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("method")) {
- res.setMethod(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "dose")) {
- res.setDose(parseType("dose", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("maxDosePerPeriod")) {
- res.setMaxDosePerPeriod(parseRatio(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("maxDosePerAdministration")) {
- res.setMaxDosePerAdministration(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("maxDosePerLifetime")) {
- res.setMaxDosePerLifetime(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "rate")) {
- res.setRate(parseType("rate", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationOrder.MedicationOrderDispenseRequestComponent parseMedicationOrderMedicationOrderDispenseRequestComponent(XmlPullParser xpp, MedicationOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationOrder.MedicationOrderDispenseRequestComponent res = new MedicationOrder.MedicationOrderDispenseRequestComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationOrderMedicationOrderDispenseRequestComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationOrderMedicationOrderDispenseRequestComponentContent(int eventType, XmlPullParser xpp, MedicationOrder owner, MedicationOrder.MedicationOrderDispenseRequestComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("validityPeriod")) {
- res.setValidityPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("numberOfRepeatsAllowed")) {
- res.setNumberOfRepeatsAllowedElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("expectedSupplyDuration")) {
- res.setExpectedSupplyDuration(parseDuration(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationOrder.MedicationOrderSubstitutionComponent parseMedicationOrderMedicationOrderSubstitutionComponent(XmlPullParser xpp, MedicationOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationOrder.MedicationOrderSubstitutionComponent res = new MedicationOrder.MedicationOrderSubstitutionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationOrderMedicationOrderSubstitutionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationOrderMedicationOrderSubstitutionComponentContent(int eventType, XmlPullParser xpp, MedicationOrder owner, MedicationOrder.MedicationOrderSubstitutionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("allowed")) {
- res.setAllowedElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationOrder.MedicationOrderEventHistoryComponent parseMedicationOrderMedicationOrderEventHistoryComponent(XmlPullParser xpp, MedicationOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationOrder.MedicationOrderEventHistoryComponent res = new MedicationOrder.MedicationOrderEventHistoryComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationOrderMedicationOrderEventHistoryComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationOrderMedicationOrderEventHistoryComponentContent(int eventType, XmlPullParser xpp, MedicationOrder owner, MedicationOrder.MedicationOrderEventHistoryComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, MedicationOrder.MedicationOrderStatus.NULL, new MedicationOrder.MedicationOrderStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.setAction(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateTime")) {
- res.setDateTimeElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationStatement parseMedicationStatement(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationStatement res = new MedicationStatement();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationStatementContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationStatementContent(int eventType, XmlPullParser xpp, MedicationStatement res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, MedicationStatement.MedicationStatementStatus.NULL, new MedicationStatement.MedicationStatementStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "medication")) {
- res.setMedication(parseType("medication", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "effective")) {
- res.setEffective(parseType("effective", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("informationSource")) {
- res.setInformationSource(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supportingInformation")) {
- res.getSupportingInformation().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateAsserted")) {
- res.setDateAssertedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("wasNotTaken")) {
- res.setWasNotTakenElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reasonNotTaken")) {
- res.getReasonNotTaken().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reasonForUseCode")) {
- res.getReasonForUseCode().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reasonForUseReference")) {
- res.getReasonForUseReference().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dosage")) {
- res.getDosage().add(parseMedicationStatementMedicationStatementDosageComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MedicationStatement.MedicationStatementDosageComponent parseMedicationStatementMedicationStatementDosageComponent(XmlPullParser xpp, MedicationStatement owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MedicationStatement.MedicationStatementDosageComponent res = new MedicationStatement.MedicationStatementDosageComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMedicationStatementMedicationStatementDosageComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMedicationStatementMedicationStatementDosageComponentContent(int eventType, XmlPullParser xpp, MedicationStatement owner, MedicationStatement.MedicationStatementDosageComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("additionalInstructions")) {
- res.getAdditionalInstructions().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("timing")) {
- res.setTiming(parseTiming(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "asNeeded")) {
- res.setAsNeeded(parseType("asNeeded", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "site")) {
- res.setSite(parseType("site", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("route")) {
- res.setRoute(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("method")) {
- res.setMethod(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "dose")) {
- res.setDose(parseType("dose", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "rate")) {
- res.setRate(parseType("rate", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("maxDosePerPeriod")) {
- res.setMaxDosePerPeriod(parseRatio(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MessageHeader parseMessageHeader(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- MessageHeader res = new MessageHeader();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMessageHeaderContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMessageHeaderContent(int eventType, XmlPullParser xpp, MessageHeader res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("timestamp")) {
- res.setTimestampElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("event")) {
- res.setEvent(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("response")) {
- res.setResponse(parseMessageHeaderMessageHeaderResponseComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("source")) {
- res.setSource(parseMessageHeaderMessageSourceComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("destination")) {
- res.getDestination().add(parseMessageHeaderMessageDestinationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("enterer")) {
- res.setEnterer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.setAuthor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("receiver")) {
- res.setReceiver(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("responsible")) {
- res.setResponsible(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("data")) {
- res.getData().add(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MessageHeader.MessageHeaderResponseComponent parseMessageHeaderMessageHeaderResponseComponent(XmlPullParser xpp, MessageHeader owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MessageHeader.MessageHeaderResponseComponent res = new MessageHeader.MessageHeaderResponseComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMessageHeaderMessageHeaderResponseComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMessageHeaderMessageHeaderResponseComponentContent(int eventType, XmlPullParser xpp, MessageHeader owner, MessageHeader.MessageHeaderResponseComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifierElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseEnumeration(xpp, MessageHeader.ResponseType.NULL, new MessageHeader.ResponseTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("details")) {
- res.setDetails(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MessageHeader.MessageSourceComponent parseMessageHeaderMessageSourceComponent(XmlPullParser xpp, MessageHeader owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MessageHeader.MessageSourceComponent res = new MessageHeader.MessageSourceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMessageHeaderMessageSourceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMessageHeaderMessageSourceComponentContent(int eventType, XmlPullParser xpp, MessageHeader owner, MessageHeader.MessageSourceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("software")) {
- res.setSoftwareElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.setContact(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("endpoint")) {
- res.setEndpointElement(parseUri(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected MessageHeader.MessageDestinationComponent parseMessageHeaderMessageDestinationComponent(XmlPullParser xpp, MessageHeader owner) throws XmlPullParserException, IOException, FHIRFormatError {
- MessageHeader.MessageDestinationComponent res = new MessageHeader.MessageDestinationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseMessageHeaderMessageDestinationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseMessageHeaderMessageDestinationComponentContent(int eventType, XmlPullParser xpp, MessageHeader owner, MessageHeader.MessageDestinationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.setTarget(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("endpoint")) {
- res.setEndpointElement(parseUri(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleDefinition parseModuleDefinition(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleDefinition res = new ModuleDefinition();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleDefinitionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleDefinitionContent(int eventType, XmlPullParser xpp, ModuleDefinition res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("model")) {
- res.getModel().add(parseModuleDefinitionModuleDefinitionModelComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("library")) {
- res.getLibrary().add(parseModuleDefinitionModuleDefinitionLibraryComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("codeSystem")) {
- res.getCodeSystem().add(parseModuleDefinitionModuleDefinitionCodeSystemComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("valueSet")) {
- res.getValueSet().add(parseModuleDefinitionModuleDefinitionValueSetComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parameter")) {
- res.getParameter().add(parseModuleDefinitionModuleDefinitionParameterComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("data")) {
- res.getData().add(parseModuleDefinitionModuleDefinitionDataComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleDefinition.ModuleDefinitionModelComponent parseModuleDefinitionModuleDefinitionModelComponent(XmlPullParser xpp, ModuleDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleDefinition.ModuleDefinitionModelComponent res = new ModuleDefinition.ModuleDefinitionModelComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleDefinitionModuleDefinitionModelComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleDefinitionModuleDefinitionModelComponentContent(int eventType, XmlPullParser xpp, ModuleDefinition owner, ModuleDefinition.ModuleDefinitionModelComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifierElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleDefinition.ModuleDefinitionLibraryComponent parseModuleDefinitionModuleDefinitionLibraryComponent(XmlPullParser xpp, ModuleDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleDefinition.ModuleDefinitionLibraryComponent res = new ModuleDefinition.ModuleDefinitionLibraryComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleDefinitionModuleDefinitionLibraryComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleDefinitionModuleDefinitionLibraryComponentContent(int eventType, XmlPullParser xpp, ModuleDefinition owner, ModuleDefinition.ModuleDefinitionLibraryComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifierElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "document")) {
- res.setDocument(parseType("document", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleDefinition.ModuleDefinitionCodeSystemComponent parseModuleDefinitionModuleDefinitionCodeSystemComponent(XmlPullParser xpp, ModuleDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleDefinition.ModuleDefinitionCodeSystemComponent res = new ModuleDefinition.ModuleDefinitionCodeSystemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleDefinitionModuleDefinitionCodeSystemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleDefinitionModuleDefinitionCodeSystemComponentContent(int eventType, XmlPullParser xpp, ModuleDefinition owner, ModuleDefinition.ModuleDefinitionCodeSystemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifierElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleDefinition.ModuleDefinitionValueSetComponent parseModuleDefinitionModuleDefinitionValueSetComponent(XmlPullParser xpp, ModuleDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleDefinition.ModuleDefinitionValueSetComponent res = new ModuleDefinition.ModuleDefinitionValueSetComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleDefinitionModuleDefinitionValueSetComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleDefinitionModuleDefinitionValueSetComponentContent(int eventType, XmlPullParser xpp, ModuleDefinition owner, ModuleDefinition.ModuleDefinitionValueSetComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifierElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("codeSystem")) {
- res.getCodeSystem().add(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleDefinition.ModuleDefinitionParameterComponent parseModuleDefinitionModuleDefinitionParameterComponent(XmlPullParser xpp, ModuleDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleDefinition.ModuleDefinitionParameterComponent res = new ModuleDefinition.ModuleDefinitionParameterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleDefinitionModuleDefinitionParameterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleDefinitionModuleDefinitionParameterComponentContent(int eventType, XmlPullParser xpp, ModuleDefinition owner, ModuleDefinition.ModuleDefinitionParameterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUseElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.setProfile(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleDefinition.ModuleDefinitionDataComponent parseModuleDefinitionModuleDefinitionDataComponent(XmlPullParser xpp, ModuleDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleDefinition.ModuleDefinitionDataComponent res = new ModuleDefinition.ModuleDefinitionDataComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleDefinitionModuleDefinitionDataComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleDefinitionModuleDefinitionDataComponentContent(int eventType, XmlPullParser xpp, ModuleDefinition owner, ModuleDefinition.ModuleDefinitionDataComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.setProfile(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mustSupport")) {
- res.getMustSupport().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("codeFilter")) {
- res.getCodeFilter().add(parseModuleDefinitionModuleDefinitionDataCodeFilterComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateFilter")) {
- res.getDateFilter().add(parseModuleDefinitionModuleDefinitionDataDateFilterComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleDefinition.ModuleDefinitionDataCodeFilterComponent parseModuleDefinitionModuleDefinitionDataCodeFilterComponent(XmlPullParser xpp, ModuleDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleDefinition.ModuleDefinitionDataCodeFilterComponent res = new ModuleDefinition.ModuleDefinitionDataCodeFilterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleDefinitionModuleDefinitionDataCodeFilterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleDefinitionModuleDefinitionDataCodeFilterComponentContent(int eventType, XmlPullParser xpp, ModuleDefinition owner, ModuleDefinition.ModuleDefinitionDataCodeFilterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("path")) {
- res.setPathElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "valueSet")) {
- res.setValueSet(parseType("valueSet", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("codeableConcept")) {
- res.getCodeableConcept().add(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ModuleDefinition.ModuleDefinitionDataDateFilterComponent parseModuleDefinitionModuleDefinitionDataDateFilterComponent(XmlPullParser xpp, ModuleDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ModuleDefinition.ModuleDefinitionDataDateFilterComponent res = new ModuleDefinition.ModuleDefinitionDataDateFilterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseModuleDefinitionModuleDefinitionDataDateFilterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseModuleDefinitionModuleDefinitionDataDateFilterComponentContent(int eventType, XmlPullParser xpp, ModuleDefinition owner, ModuleDefinition.ModuleDefinitionDataDateFilterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("path")) {
- res.setPathElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected NamingSystem parseNamingSystem(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- NamingSystem res = new NamingSystem();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseNamingSystemContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseNamingSystemContent(int eventType, XmlPullParser xpp, NamingSystem res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("kind")) {
- res.setKindElement(parseEnumeration(xpp, NamingSystem.NamingSystemType.NULL, new NamingSystem.NamingSystemTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseNamingSystemNamingSystemContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("responsible")) {
- res.setResponsibleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("usage")) {
- res.setUsageElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("uniqueId")) {
- res.getUniqueId().add(parseNamingSystemNamingSystemUniqueIdComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("replacedBy")) {
- res.setReplacedBy(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected NamingSystem.NamingSystemContactComponent parseNamingSystemNamingSystemContactComponent(XmlPullParser xpp, NamingSystem owner) throws XmlPullParserException, IOException, FHIRFormatError {
- NamingSystem.NamingSystemContactComponent res = new NamingSystem.NamingSystemContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseNamingSystemNamingSystemContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseNamingSystemNamingSystemContactComponentContent(int eventType, XmlPullParser xpp, NamingSystem owner, NamingSystem.NamingSystemContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected NamingSystem.NamingSystemUniqueIdComponent parseNamingSystemNamingSystemUniqueIdComponent(XmlPullParser xpp, NamingSystem owner) throws XmlPullParserException, IOException, FHIRFormatError {
- NamingSystem.NamingSystemUniqueIdComponent res = new NamingSystem.NamingSystemUniqueIdComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseNamingSystemNamingSystemUniqueIdComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseNamingSystemNamingSystemUniqueIdComponentContent(int eventType, XmlPullParser xpp, NamingSystem owner, NamingSystem.NamingSystemUniqueIdComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, NamingSystem.NamingSystemIdentifierType.NULL, new NamingSystem.NamingSystemIdentifierTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("preferred")) {
- res.setPreferredElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected NutritionOrder parseNutritionOrder(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- NutritionOrder res = new NutritionOrder();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseNutritionOrderContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseNutritionOrderContent(int eventType, XmlPullParser xpp, NutritionOrder res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, NutritionOrder.NutritionOrderStatus.NULL, new NutritionOrder.NutritionOrderStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateTime")) {
- res.setDateTimeElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("orderer")) {
- res.setOrderer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("allergyIntolerance")) {
- res.getAllergyIntolerance().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("foodPreferenceModifier")) {
- res.getFoodPreferenceModifier().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("excludeFoodModifier")) {
- res.getExcludeFoodModifier().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("oralDiet")) {
- res.setOralDiet(parseNutritionOrderNutritionOrderOralDietComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supplement")) {
- res.getSupplement().add(parseNutritionOrderNutritionOrderSupplementComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("enteralFormula")) {
- res.setEnteralFormula(parseNutritionOrderNutritionOrderEnteralFormulaComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected NutritionOrder.NutritionOrderOralDietComponent parseNutritionOrderNutritionOrderOralDietComponent(XmlPullParser xpp, NutritionOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- NutritionOrder.NutritionOrderOralDietComponent res = new NutritionOrder.NutritionOrderOralDietComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseNutritionOrderNutritionOrderOralDietComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseNutritionOrderNutritionOrderOralDietComponentContent(int eventType, XmlPullParser xpp, NutritionOrder owner, NutritionOrder.NutritionOrderOralDietComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("schedule")) {
- res.getSchedule().add(parseTiming(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("nutrient")) {
- res.getNutrient().add(parseNutritionOrderNutritionOrderOralDietNutrientComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("texture")) {
- res.getTexture().add(parseNutritionOrderNutritionOrderOralDietTextureComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fluidConsistencyType")) {
- res.getFluidConsistencyType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("instruction")) {
- res.setInstructionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected NutritionOrder.NutritionOrderOralDietNutrientComponent parseNutritionOrderNutritionOrderOralDietNutrientComponent(XmlPullParser xpp, NutritionOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- NutritionOrder.NutritionOrderOralDietNutrientComponent res = new NutritionOrder.NutritionOrderOralDietNutrientComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseNutritionOrderNutritionOrderOralDietNutrientComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseNutritionOrderNutritionOrderOralDietNutrientComponentContent(int eventType, XmlPullParser xpp, NutritionOrder owner, NutritionOrder.NutritionOrderOralDietNutrientComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("modifier")) {
- res.setModifier(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("amount")) {
- res.setAmount(parseSimpleQuantity(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected NutritionOrder.NutritionOrderOralDietTextureComponent parseNutritionOrderNutritionOrderOralDietTextureComponent(XmlPullParser xpp, NutritionOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- NutritionOrder.NutritionOrderOralDietTextureComponent res = new NutritionOrder.NutritionOrderOralDietTextureComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseNutritionOrderNutritionOrderOralDietTextureComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseNutritionOrderNutritionOrderOralDietTextureComponentContent(int eventType, XmlPullParser xpp, NutritionOrder owner, NutritionOrder.NutritionOrderOralDietTextureComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("modifier")) {
- res.setModifier(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("foodType")) {
- res.setFoodType(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected NutritionOrder.NutritionOrderSupplementComponent parseNutritionOrderNutritionOrderSupplementComponent(XmlPullParser xpp, NutritionOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- NutritionOrder.NutritionOrderSupplementComponent res = new NutritionOrder.NutritionOrderSupplementComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseNutritionOrderNutritionOrderSupplementComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseNutritionOrderNutritionOrderSupplementComponentContent(int eventType, XmlPullParser xpp, NutritionOrder owner, NutritionOrder.NutritionOrderSupplementComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("productName")) {
- res.setProductNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("schedule")) {
- res.getSchedule().add(parseTiming(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("instruction")) {
- res.setInstructionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected NutritionOrder.NutritionOrderEnteralFormulaComponent parseNutritionOrderNutritionOrderEnteralFormulaComponent(XmlPullParser xpp, NutritionOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- NutritionOrder.NutritionOrderEnteralFormulaComponent res = new NutritionOrder.NutritionOrderEnteralFormulaComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseNutritionOrderNutritionOrderEnteralFormulaComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseNutritionOrderNutritionOrderEnteralFormulaComponentContent(int eventType, XmlPullParser xpp, NutritionOrder owner, NutritionOrder.NutritionOrderEnteralFormulaComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("baseFormulaType")) {
- res.setBaseFormulaType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("baseFormulaProductName")) {
- res.setBaseFormulaProductNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("additiveType")) {
- res.setAdditiveType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("additiveProductName")) {
- res.setAdditiveProductNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("caloricDensity")) {
- res.setCaloricDensity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("routeofAdministration")) {
- res.setRouteofAdministration(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("administration")) {
- res.getAdministration().add(parseNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("maxVolumeToDeliver")) {
- res.setMaxVolumeToDeliver(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("administrationInstruction")) {
- res.setAdministrationInstructionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent parseNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(XmlPullParser xpp, NutritionOrder owner) throws XmlPullParserException, IOException, FHIRFormatError {
- NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent res = new NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseNutritionOrderNutritionOrderEnteralFormulaAdministrationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseNutritionOrderNutritionOrderEnteralFormulaAdministrationComponentContent(int eventType, XmlPullParser xpp, NutritionOrder owner, NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("schedule")) {
- res.setSchedule(parseTiming(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "rate")) {
- res.setRate(parseType("rate", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Observation parseObservation(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Observation res = new Observation();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseObservationContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseObservationContent(int eventType, XmlPullParser xpp, Observation res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Observation.ObservationStatus.NULL, new Observation.ObservationStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.getCategory().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "effective")) {
- res.setEffective(parseType("effective", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("issued")) {
- res.setIssuedElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("performer")) {
- res.getPerformer().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dataAbsentReason")) {
- res.setDataAbsentReason(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("interpretation")) {
- res.setInterpretation(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comment")) {
- res.setCommentElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("bodySite")) {
- res.setBodySite(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("method")) {
- res.setMethod(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specimen")) {
- res.setSpecimen(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("device")) {
- res.setDevice(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("referenceRange")) {
- res.getReferenceRange().add(parseObservationObservationReferenceRangeComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("related")) {
- res.getRelated().add(parseObservationObservationRelatedComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("component")) {
- res.getComponent().add(parseObservationObservationComponentComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Observation.ObservationReferenceRangeComponent parseObservationObservationReferenceRangeComponent(XmlPullParser xpp, Observation owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Observation.ObservationReferenceRangeComponent res = new Observation.ObservationReferenceRangeComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseObservationObservationReferenceRangeComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseObservationObservationReferenceRangeComponentContent(int eventType, XmlPullParser xpp, Observation owner, Observation.ObservationReferenceRangeComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("low")) {
- res.setLow(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("high")) {
- res.setHigh(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("meaning")) {
- res.getMeaning().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("age")) {
- res.setAge(parseRange(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Observation.ObservationRelatedComponent parseObservationObservationRelatedComponent(XmlPullParser xpp, Observation owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Observation.ObservationRelatedComponent res = new Observation.ObservationRelatedComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseObservationObservationRelatedComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseObservationObservationRelatedComponentContent(int eventType, XmlPullParser xpp, Observation owner, Observation.ObservationRelatedComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Observation.ObservationRelationshipType.NULL, new Observation.ObservationRelationshipTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.setTarget(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Observation.ObservationComponentComponent parseObservationObservationComponentComponent(XmlPullParser xpp, Observation owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Observation.ObservationComponentComponent res = new Observation.ObservationComponentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseObservationObservationComponentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseObservationObservationComponentComponentContent(int eventType, XmlPullParser xpp, Observation owner, Observation.ObservationComponentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dataAbsentReason")) {
- res.setDataAbsentReason(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("interpretation")) {
- res.setInterpretation(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("referenceRange")) {
- res.getReferenceRange().add(parseObservationObservationReferenceRangeComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected OperationDefinition parseOperationDefinition(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- OperationDefinition res = new OperationDefinition();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOperationDefinitionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOperationDefinitionContent(int eventType, XmlPullParser xpp, OperationDefinition res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("kind")) {
- res.setKindElement(parseEnumeration(xpp, OperationDefinition.OperationKind.NULL, new OperationDefinition.OperationKindEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseOperationDefinitionOperationDefinitionContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("idempotent")) {
- res.setIdempotentElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comment")) {
- res.setCommentElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("base")) {
- res.setBase(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.getType().add(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("instance")) {
- res.setInstanceElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parameter")) {
- res.getParameter().add(parseOperationDefinitionOperationDefinitionParameterComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected OperationDefinition.OperationDefinitionContactComponent parseOperationDefinitionOperationDefinitionContactComponent(XmlPullParser xpp, OperationDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- OperationDefinition.OperationDefinitionContactComponent res = new OperationDefinition.OperationDefinitionContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOperationDefinitionOperationDefinitionContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOperationDefinitionOperationDefinitionContactComponentContent(int eventType, XmlPullParser xpp, OperationDefinition owner, OperationDefinition.OperationDefinitionContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected OperationDefinition.OperationDefinitionParameterComponent parseOperationDefinitionOperationDefinitionParameterComponent(XmlPullParser xpp, OperationDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- OperationDefinition.OperationDefinitionParameterComponent res = new OperationDefinition.OperationDefinitionParameterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOperationDefinitionOperationDefinitionParameterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOperationDefinitionOperationDefinitionParameterComponentContent(int eventType, XmlPullParser xpp, OperationDefinition owner, OperationDefinition.OperationDefinitionParameterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUseElement(parseEnumeration(xpp, OperationDefinition.OperationParameterUse.NULL, new OperationDefinition.OperationParameterUseEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("min")) {
- res.setMinElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("max")) {
- res.setMaxElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("searchType")) {
- res.setSearchTypeElement(parseEnumeration(xpp, Enumerations.SearchParamType.NULL, new Enumerations.SearchParamTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.setProfile(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("binding")) {
- res.setBinding(parseOperationDefinitionOperationDefinitionParameterBindingComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("part")) {
- res.getPart().add(parseOperationDefinitionOperationDefinitionParameterComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected OperationDefinition.OperationDefinitionParameterBindingComponent parseOperationDefinitionOperationDefinitionParameterBindingComponent(XmlPullParser xpp, OperationDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- OperationDefinition.OperationDefinitionParameterBindingComponent res = new OperationDefinition.OperationDefinitionParameterBindingComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOperationDefinitionOperationDefinitionParameterBindingComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOperationDefinitionOperationDefinitionParameterBindingComponentContent(int eventType, XmlPullParser xpp, OperationDefinition owner, OperationDefinition.OperationDefinitionParameterBindingComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("strength")) {
- res.setStrengthElement(parseEnumeration(xpp, Enumerations.BindingStrength.NULL, new Enumerations.BindingStrengthEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "valueSet")) {
- res.setValueSet(parseType("valueSet", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected OperationOutcome parseOperationOutcome(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- OperationOutcome res = new OperationOutcome();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOperationOutcomeContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOperationOutcomeContent(int eventType, XmlPullParser xpp, OperationOutcome res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("issue")) {
- res.getIssue().add(parseOperationOutcomeOperationOutcomeIssueComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected OperationOutcome.OperationOutcomeIssueComponent parseOperationOutcomeOperationOutcomeIssueComponent(XmlPullParser xpp, OperationOutcome owner) throws XmlPullParserException, IOException, FHIRFormatError {
- OperationOutcome.OperationOutcomeIssueComponent res = new OperationOutcome.OperationOutcomeIssueComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOperationOutcomeOperationOutcomeIssueComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOperationOutcomeOperationOutcomeIssueComponentContent(int eventType, XmlPullParser xpp, OperationOutcome owner, OperationOutcome.OperationOutcomeIssueComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("severity")) {
- res.setSeverityElement(parseEnumeration(xpp, OperationOutcome.IssueSeverity.NULL, new OperationOutcome.IssueSeverityEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseEnumeration(xpp, OperationOutcome.IssueType.NULL, new OperationOutcome.IssueTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("details")) {
- res.setDetails(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("diagnostics")) {
- res.setDiagnosticsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.getLocation().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("expression")) {
- res.getExpression().add(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Order parseOrder(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Order res = new Order();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOrderContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOrderContent(int eventType, XmlPullParser xpp, Order res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("source")) {
- res.setSource(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.setTarget(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "reason")) {
- res.setReason(parseType("reason", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("when")) {
- res.setWhen(parseOrderOrderWhenComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.getDetail().add(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Order.OrderWhenComponent parseOrderOrderWhenComponent(XmlPullParser xpp, Order owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Order.OrderWhenComponent res = new Order.OrderWhenComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOrderOrderWhenComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOrderOrderWhenComponentContent(int eventType, XmlPullParser xpp, Order owner, Order.OrderWhenComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("schedule")) {
- res.setSchedule(parseTiming(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected OrderResponse parseOrderResponse(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- OrderResponse res = new OrderResponse();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOrderResponseContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOrderResponseContent(int eventType, XmlPullParser xpp, OrderResponse res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("request")) {
- res.setRequest(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("who")) {
- res.setWho(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("orderStatus")) {
- res.setOrderStatusElement(parseEnumeration(xpp, OrderResponse.OrderStatus.NULL, new OrderResponse.OrderStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fulfillment")) {
- res.getFulfillment().add(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected OrderSet parseOrderSet(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- OrderSet res = new OrderSet();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOrderSetContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOrderSetContent(int eventType, XmlPullParser xpp, OrderSet res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("moduleMetadata")) {
- res.setModuleMetadata(parseModuleMetadata(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("library")) {
- res.getLibrary().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseActionDefinition(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Organization parseOrganization(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Organization res = new Organization();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOrganizationContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOrganizationContent(int eventType, XmlPullParser xpp, Organization res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("active")) {
- res.setActiveElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("address")) {
- res.getAddress().add(parseAddress(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("partOf")) {
- res.setPartOf(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseOrganizationOrganizationContactComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Organization.OrganizationContactComponent parseOrganizationOrganizationContactComponent(XmlPullParser xpp, Organization owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Organization.OrganizationContactComponent res = new Organization.OrganizationContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseOrganizationOrganizationContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseOrganizationOrganizationContactComponentContent(int eventType, XmlPullParser xpp, Organization owner, Organization.OrganizationContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("purpose")) {
- res.setPurpose(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setName(parseHumanName(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("address")) {
- res.setAddress(parseAddress(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Patient parsePatient(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Patient res = new Patient();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePatientContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePatientContent(int eventType, XmlPullParser xpp, Patient res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("active")) {
- res.setActiveElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.getName().add(parseHumanName(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("gender")) {
- res.setGenderElement(parseEnumeration(xpp, Enumerations.AdministrativeGender.NULL, new Enumerations.AdministrativeGenderEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("birthDate")) {
- res.setBirthDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "deceased")) {
- res.setDeceased(parseType("deceased", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("address")) {
- res.getAddress().add(parseAddress(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("maritalStatus")) {
- res.setMaritalStatus(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "multipleBirth")) {
- res.setMultipleBirth(parseType("multipleBirth", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("photo")) {
- res.getPhoto().add(parseAttachment(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parsePatientContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("animal")) {
- res.setAnimal(parsePatientAnimalComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("communication")) {
- res.getCommunication().add(parsePatientPatientCommunicationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("careProvider")) {
- res.getCareProvider().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("managingOrganization")) {
- res.setManagingOrganization(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("link")) {
- res.getLink().add(parsePatientPatientLinkComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Patient.ContactComponent parsePatientContactComponent(XmlPullParser xpp, Patient owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Patient.ContactComponent res = new Patient.ContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePatientContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePatientContactComponentContent(int eventType, XmlPullParser xpp, Patient owner, Patient.ContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relationship")) {
- res.getRelationship().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setName(parseHumanName(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("address")) {
- res.setAddress(parseAddress(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("gender")) {
- res.setGenderElement(parseEnumeration(xpp, Enumerations.AdministrativeGender.NULL, new Enumerations.AdministrativeGenderEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("organization")) {
- res.setOrganization(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Patient.AnimalComponent parsePatientAnimalComponent(XmlPullParser xpp, Patient owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Patient.AnimalComponent res = new Patient.AnimalComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePatientAnimalComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePatientAnimalComponentContent(int eventType, XmlPullParser xpp, Patient owner, Patient.AnimalComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("species")) {
- res.setSpecies(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("breed")) {
- res.setBreed(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("genderStatus")) {
- res.setGenderStatus(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Patient.PatientCommunicationComponent parsePatientPatientCommunicationComponent(XmlPullParser xpp, Patient owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Patient.PatientCommunicationComponent res = new Patient.PatientCommunicationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePatientPatientCommunicationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePatientPatientCommunicationComponentContent(int eventType, XmlPullParser xpp, Patient owner, Patient.PatientCommunicationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("language")) {
- res.setLanguage(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("preferred")) {
- res.setPreferredElement(parseBoolean(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Patient.PatientLinkComponent parsePatientPatientLinkComponent(XmlPullParser xpp, Patient owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Patient.PatientLinkComponent res = new Patient.PatientLinkComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePatientPatientLinkComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePatientPatientLinkComponentContent(int eventType, XmlPullParser xpp, Patient owner, Patient.PatientLinkComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("other")) {
- res.setOther(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Patient.LinkType.NULL, new Patient.LinkTypeEnumFactory()));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected PaymentNotice parsePaymentNotice(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- PaymentNotice res = new PaymentNotice();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePaymentNoticeContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePaymentNoticeContent(int eventType, XmlPullParser xpp, PaymentNotice res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "target")) {
- res.setTarget(parseType("target", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "provider")) {
- res.setProvider(parseType("provider", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "organization")) {
- res.setOrganization(parseType("organization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "request")) {
- res.setRequest(parseType("request", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "response")) {
- res.setResponse(parseType("response", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("paymentStatus")) {
- res.setPaymentStatus(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("statusDate")) {
- res.setStatusDateElement(parseDate(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected PaymentReconciliation parsePaymentReconciliation(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- PaymentReconciliation res = new PaymentReconciliation();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePaymentReconciliationContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePaymentReconciliationContent(int eventType, XmlPullParser xpp, PaymentReconciliation res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "request")) {
- res.setRequest(parseType("request", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outcome")) {
- res.setOutcomeElement(parseEnumeration(xpp, Enumerations.RemittanceOutcome.NULL, new Enumerations.RemittanceOutcomeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("disposition")) {
- res.setDispositionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "organization")) {
- res.setOrganization(parseType("organization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "requestProvider")) {
- res.setRequestProvider(parseType("requestProvider", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "requestOrganization")) {
- res.setRequestOrganization(parseType("requestOrganization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.getDetail().add(parsePaymentReconciliationDetailsComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("form")) {
- res.setForm(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("total")) {
- res.setTotal(parseMoney(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parsePaymentReconciliationNotesComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected PaymentReconciliation.DetailsComponent parsePaymentReconciliationDetailsComponent(XmlPullParser xpp, PaymentReconciliation owner) throws XmlPullParserException, IOException, FHIRFormatError {
- PaymentReconciliation.DetailsComponent res = new PaymentReconciliation.DetailsComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePaymentReconciliationDetailsComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePaymentReconciliationDetailsComponentContent(int eventType, XmlPullParser xpp, PaymentReconciliation owner, PaymentReconciliation.DetailsComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "request")) {
- res.setRequest(parseType("request", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "responce")) {
- res.setResponce(parseType("responce", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "submitter")) {
- res.setSubmitter(parseType("submitter", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "payee")) {
- res.setPayee(parseType("payee", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("amount")) {
- res.setAmount(parseMoney(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected PaymentReconciliation.NotesComponent parsePaymentReconciliationNotesComponent(XmlPullParser xpp, PaymentReconciliation owner) throws XmlPullParserException, IOException, FHIRFormatError {
- PaymentReconciliation.NotesComponent res = new PaymentReconciliation.NotesComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePaymentReconciliationNotesComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePaymentReconciliationNotesComponentContent(int eventType, XmlPullParser xpp, PaymentReconciliation owner, PaymentReconciliation.NotesComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Person parsePerson(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Person res = new Person();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePersonContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePersonContent(int eventType, XmlPullParser xpp, Person res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.getName().add(parseHumanName(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("gender")) {
- res.setGenderElement(parseEnumeration(xpp, Enumerations.AdministrativeGender.NULL, new Enumerations.AdministrativeGenderEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("birthDate")) {
- res.setBirthDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("address")) {
- res.getAddress().add(parseAddress(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("photo")) {
- res.setPhoto(parseAttachment(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("managingOrganization")) {
- res.setManagingOrganization(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("active")) {
- res.setActiveElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("link")) {
- res.getLink().add(parsePersonPersonLinkComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Person.PersonLinkComponent parsePersonPersonLinkComponent(XmlPullParser xpp, Person owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Person.PersonLinkComponent res = new Person.PersonLinkComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePersonPersonLinkComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePersonPersonLinkComponentContent(int eventType, XmlPullParser xpp, Person owner, Person.PersonLinkComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.setTarget(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("assurance")) {
- res.setAssuranceElement(parseEnumeration(xpp, Person.IdentityAssuranceLevel.NULL, new Person.IdentityAssuranceLevelEnumFactory()));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Practitioner parsePractitioner(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Practitioner res = new Practitioner();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePractitionerContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePractitionerContent(int eventType, XmlPullParser xpp, Practitioner res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("active")) {
- res.setActiveElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.getName().add(parseHumanName(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("address")) {
- res.getAddress().add(parseAddress(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("gender")) {
- res.setGenderElement(parseEnumeration(xpp, Enumerations.AdministrativeGender.NULL, new Enumerations.AdministrativeGenderEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("birthDate")) {
- res.setBirthDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("photo")) {
- res.getPhoto().add(parseAttachment(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("practitionerRole")) {
- res.getPractitionerRole().add(parsePractitionerPractitionerPractitionerRoleComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("qualification")) {
- res.getQualification().add(parsePractitionerPractitionerQualificationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("communication")) {
- res.getCommunication().add(parseCodeableConcept(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Practitioner.PractitionerPractitionerRoleComponent parsePractitionerPractitionerPractitionerRoleComponent(XmlPullParser xpp, Practitioner owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Practitioner.PractitionerPractitionerRoleComponent res = new Practitioner.PractitionerPractitionerRoleComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePractitionerPractitionerPractitionerRoleComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePractitionerPractitionerPractitionerRoleComponentContent(int eventType, XmlPullParser xpp, Practitioner owner, Practitioner.PractitionerPractitionerRoleComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("organization")) {
- res.setOrganization(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.setRole(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specialty")) {
- res.getSpecialty().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.getLocation().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("healthcareService")) {
- res.getHealthcareService().add(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Practitioner.PractitionerQualificationComponent parsePractitionerPractitionerQualificationComponent(XmlPullParser xpp, Practitioner owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Practitioner.PractitionerQualificationComponent res = new Practitioner.PractitionerQualificationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePractitionerPractitionerQualificationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePractitionerPractitionerQualificationComponentContent(int eventType, XmlPullParser xpp, Practitioner owner, Practitioner.PractitionerQualificationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("issuer")) {
- res.setIssuer(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected PractitionerRole parsePractitionerRole(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- PractitionerRole res = new PractitionerRole();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePractitionerRoleContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePractitionerRoleContent(int eventType, XmlPullParser xpp, PractitionerRole res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("active")) {
- res.setActiveElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("practitioner")) {
- res.setPractitioner(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("organization")) {
- res.setOrganization(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.getRole().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specialty")) {
- res.getSpecialty().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.getLocation().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("healthcareService")) {
- res.getHealthcareService().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("availableTime")) {
- res.getAvailableTime().add(parsePractitionerRolePractitionerRoleAvailableTimeComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("notAvailable")) {
- res.getNotAvailable().add(parsePractitionerRolePractitionerRoleNotAvailableComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("availabilityExceptions")) {
- res.setAvailabilityExceptionsElement(parseString(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected PractitionerRole.PractitionerRoleAvailableTimeComponent parsePractitionerRolePractitionerRoleAvailableTimeComponent(XmlPullParser xpp, PractitionerRole owner) throws XmlPullParserException, IOException, FHIRFormatError {
- PractitionerRole.PractitionerRoleAvailableTimeComponent res = new PractitionerRole.PractitionerRoleAvailableTimeComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePractitionerRolePractitionerRoleAvailableTimeComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePractitionerRolePractitionerRoleAvailableTimeComponentContent(int eventType, XmlPullParser xpp, PractitionerRole owner, PractitionerRole.PractitionerRoleAvailableTimeComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("daysOfWeek")) {
- res.getDaysOfWeek().add(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("allDay")) {
- res.setAllDayElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("availableStartTime")) {
- res.setAvailableStartTimeElement(parseTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("availableEndTime")) {
- res.setAvailableEndTimeElement(parseTime(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected PractitionerRole.PractitionerRoleNotAvailableComponent parsePractitionerRolePractitionerRoleNotAvailableComponent(XmlPullParser xpp, PractitionerRole owner) throws XmlPullParserException, IOException, FHIRFormatError {
- PractitionerRole.PractitionerRoleNotAvailableComponent res = new PractitionerRole.PractitionerRoleNotAvailableComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parsePractitionerRolePractitionerRoleNotAvailableComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parsePractitionerRolePractitionerRoleNotAvailableComponentContent(int eventType, XmlPullParser xpp, PractitionerRole owner, PractitionerRole.PractitionerRoleNotAvailableComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("during")) {
- res.setDuring(parsePeriod(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Procedure parseProcedure(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Procedure res = new Procedure();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProcedureContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProcedureContent(int eventType, XmlPullParser xpp, Procedure res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Procedure.ProcedureStatus.NULL, new Procedure.ProcedureStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("notPerformed")) {
- res.setNotPerformedElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reasonNotPerformed")) {
- res.getReasonNotPerformed().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("bodySite")) {
- res.getBodySite().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "reason")) {
- res.setReason(parseType("reason", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("performer")) {
- res.getPerformer().add(parseProcedureProcedurePerformerComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "performed")) {
- res.setPerformed(parseType("performed", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.setLocation(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outcome")) {
- res.setOutcome(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("report")) {
- res.getReport().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("complication")) {
- res.getComplication().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("followUp")) {
- res.getFollowUp().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("request")) {
- res.setRequest(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("notes")) {
- res.getNotes().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("focalDevice")) {
- res.getFocalDevice().add(parseProcedureProcedureFocalDeviceComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("used")) {
- res.getUsed().add(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Procedure.ProcedurePerformerComponent parseProcedureProcedurePerformerComponent(XmlPullParser xpp, Procedure owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Procedure.ProcedurePerformerComponent res = new Procedure.ProcedurePerformerComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProcedureProcedurePerformerComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProcedureProcedurePerformerComponentContent(int eventType, XmlPullParser xpp, Procedure owner, Procedure.ProcedurePerformerComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.setRole(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Procedure.ProcedureFocalDeviceComponent parseProcedureProcedureFocalDeviceComponent(XmlPullParser xpp, Procedure owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Procedure.ProcedureFocalDeviceComponent res = new Procedure.ProcedureFocalDeviceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProcedureProcedureFocalDeviceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProcedureProcedureFocalDeviceComponentContent(int eventType, XmlPullParser xpp, Procedure owner, Procedure.ProcedureFocalDeviceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.setAction(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("manipulated")) {
- res.setManipulated(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ProcedureRequest parseProcedureRequest(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ProcedureRequest res = new ProcedureRequest();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProcedureRequestContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProcedureRequestContent(int eventType, XmlPullParser xpp, ProcedureRequest res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("bodySite")) {
- res.getBodySite().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "reason")) {
- res.setReason(parseType("reason", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "scheduled")) {
- res.setScheduled(parseType("scheduled", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("performer")) {
- res.setPerformer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, ProcedureRequest.ProcedureRequestStatus.NULL, new ProcedureRequest.ProcedureRequestStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("notes")) {
- res.getNotes().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "asNeeded")) {
- res.setAsNeeded(parseType("asNeeded", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("orderedOn")) {
- res.setOrderedOnElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("orderer")) {
- res.setOrderer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priority")) {
- res.setPriorityElement(parseEnumeration(xpp, ProcedureRequest.ProcedureRequestPriority.NULL, new ProcedureRequest.ProcedureRequestPriorityEnumFactory()));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ProcessRequest parseProcessRequest(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ProcessRequest res = new ProcessRequest();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProcessRequestContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProcessRequestContent(int eventType, XmlPullParser xpp, ProcessRequest res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.setActionElement(parseEnumeration(xpp, ProcessRequest.ActionList.NULL, new ProcessRequest.ActionListEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "target")) {
- res.setTarget(parseType("target", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "provider")) {
- res.setProvider(parseType("provider", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "organization")) {
- res.setOrganization(parseType("organization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "request")) {
- res.setRequest(parseType("request", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "response")) {
- res.setResponse(parseType("response", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("nullify")) {
- res.setNullifyElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reference")) {
- res.setReferenceElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseProcessRequestItemsComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("include")) {
- res.getInclude().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("exclude")) {
- res.getExclude().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ProcessRequest.ItemsComponent parseProcessRequestItemsComponent(XmlPullParser xpp, ProcessRequest owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ProcessRequest.ItemsComponent res = new ProcessRequest.ItemsComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProcessRequestItemsComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProcessRequestItemsComponentContent(int eventType, XmlPullParser xpp, ProcessRequest owner, ProcessRequest.ItemsComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequenceLinkId")) {
- res.setSequenceLinkIdElement(parseInteger(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ProcessResponse parseProcessResponse(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ProcessResponse res = new ProcessResponse();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProcessResponseContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProcessResponseContent(int eventType, XmlPullParser xpp, ProcessResponse res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "request")) {
- res.setRequest(parseType("request", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outcome")) {
- res.setOutcome(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("disposition")) {
- res.setDispositionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("originalRuleset")) {
- res.setOriginalRuleset(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "organization")) {
- res.setOrganization(parseType("organization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "requestProvider")) {
- res.setRequestProvider(parseType("requestProvider", xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "requestOrganization")) {
- res.setRequestOrganization(parseType("requestOrganization", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("form")) {
- res.setForm(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("notes")) {
- res.getNotes().add(parseProcessResponseProcessResponseNotesComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("error")) {
- res.getError().add(parseCoding(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ProcessResponse.ProcessResponseNotesComponent parseProcessResponseProcessResponseNotesComponent(XmlPullParser xpp, ProcessResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ProcessResponse.ProcessResponseNotesComponent res = new ProcessResponse.ProcessResponseNotesComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProcessResponseProcessResponseNotesComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProcessResponseProcessResponseNotesComponentContent(int eventType, XmlPullParser xpp, ProcessResponse owner, ProcessResponse.ProcessResponseNotesComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Protocol parseProtocol(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Protocol res = new Protocol();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProtocolContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProtocolContent(int eventType, XmlPullParser xpp, Protocol res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("title")) {
- res.setTitleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Protocol.ProtocolStatus.NULL, new Protocol.ProtocolStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Protocol.ProtocolType.NULL, new Protocol.ProtocolTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("group")) {
- res.setGroup(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("purpose")) {
- res.setPurposeElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.setAuthor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("step")) {
- res.getStep().add(parseProtocolProtocolStepComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Protocol.ProtocolStepComponent parseProtocolProtocolStepComponent(XmlPullParser xpp, Protocol owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Protocol.ProtocolStepComponent res = new Protocol.ProtocolStepComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProtocolProtocolStepComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProtocolProtocolStepComponentContent(int eventType, XmlPullParser xpp, Protocol owner, Protocol.ProtocolStepComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("duration")) {
- res.setDuration(parseDuration(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("precondition")) {
- res.setPrecondition(parseProtocolProtocolStepPreconditionComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("exit")) {
- res.setExit(parseProtocolProtocolStepPreconditionComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("firstActivity")) {
- res.setFirstActivityElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("activity")) {
- res.getActivity().add(parseProtocolProtocolStepActivityComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("next")) {
- res.getNext().add(parseProtocolProtocolStepNextComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Protocol.ProtocolStepPreconditionComponent parseProtocolProtocolStepPreconditionComponent(XmlPullParser xpp, Protocol owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Protocol.ProtocolStepPreconditionComponent res = new Protocol.ProtocolStepPreconditionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProtocolProtocolStepPreconditionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProtocolProtocolStepPreconditionComponentContent(int eventType, XmlPullParser xpp, Protocol owner, Protocol.ProtocolStepPreconditionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("condition")) {
- res.setCondition(parseProtocolProtocolStepPreconditionConditionComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("intersection")) {
- res.getIntersection().add(parseProtocolProtocolStepPreconditionComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("union")) {
- res.getUnion().add(parseProtocolProtocolStepPreconditionComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("exclude")) {
- res.getExclude().add(parseProtocolProtocolStepPreconditionComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Protocol.ProtocolStepPreconditionConditionComponent parseProtocolProtocolStepPreconditionConditionComponent(XmlPullParser xpp, Protocol owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Protocol.ProtocolStepPreconditionConditionComponent res = new Protocol.ProtocolStepPreconditionConditionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProtocolProtocolStepPreconditionConditionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProtocolProtocolStepPreconditionConditionComponentContent(int eventType, XmlPullParser xpp, Protocol owner, Protocol.ProtocolStepPreconditionConditionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Protocol.ProtocolStepActivityComponent parseProtocolProtocolStepActivityComponent(XmlPullParser xpp, Protocol owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Protocol.ProtocolStepActivityComponent res = new Protocol.ProtocolStepActivityComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProtocolProtocolStepActivityComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProtocolProtocolStepActivityComponentContent(int eventType, XmlPullParser xpp, Protocol owner, Protocol.ProtocolStepActivityComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("alternative")) {
- res.getAlternative().add(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("component")) {
- res.getComponent().add(parseProtocolProtocolStepActivityComponentComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("following")) {
- res.getFollowing().add(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("wait")) {
- res.setWait(parseDuration(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("detail")) {
- res.setDetail(parseProtocolProtocolStepActivityDetailComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Protocol.ProtocolStepActivityComponentComponent parseProtocolProtocolStepActivityComponentComponent(XmlPullParser xpp, Protocol owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Protocol.ProtocolStepActivityComponentComponent res = new Protocol.ProtocolStepActivityComponentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProtocolProtocolStepActivityComponentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProtocolProtocolStepActivityComponentComponentContent(int eventType, XmlPullParser xpp, Protocol owner, Protocol.ProtocolStepActivityComponentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sequence")) {
- res.setSequenceElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("activity")) {
- res.setActivityElement(parseUri(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Protocol.ProtocolStepActivityDetailComponent parseProtocolProtocolStepActivityDetailComponent(XmlPullParser xpp, Protocol owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Protocol.ProtocolStepActivityDetailComponent res = new Protocol.ProtocolStepActivityDetailComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProtocolProtocolStepActivityDetailComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProtocolProtocolStepActivityDetailComponentContent(int eventType, XmlPullParser xpp, Protocol owner, Protocol.ProtocolStepActivityDetailComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategoryElement(parseEnumeration(xpp, Protocol.ActivityDefinitionCategory.NULL, new Protocol.ActivityDefinitionCategoryEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "timing")) {
- res.setTiming(parseType("timing", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.setLocation(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("performer")) {
- res.getPerformer().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "product")) {
- res.setProduct(parseType("product", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Protocol.ProtocolStepNextComponent parseProtocolProtocolStepNextComponent(XmlPullParser xpp, Protocol owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Protocol.ProtocolStepNextComponent res = new Protocol.ProtocolStepNextComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProtocolProtocolStepNextComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProtocolProtocolStepNextComponentContent(int eventType, XmlPullParser xpp, Protocol owner, Protocol.ProtocolStepNextComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reference")) {
- res.setReferenceElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("condition")) {
- res.setCondition(parseProtocolProtocolStepPreconditionComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Provenance parseProvenance(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Provenance res = new Provenance();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProvenanceContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProvenanceContent(int eventType, XmlPullParser xpp, Provenance res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.getTarget().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recorded")) {
- res.setRecordedElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.getReason().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("activity")) {
- res.setActivity(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("location")) {
- res.setLocation(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("policy")) {
- res.getPolicy().add(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("agent")) {
- res.getAgent().add(parseProvenanceProvenanceAgentComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("entity")) {
- res.getEntity().add(parseProvenanceProvenanceEntityComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("signature")) {
- res.getSignature().add(parseSignature(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Provenance.ProvenanceAgentComponent parseProvenanceProvenanceAgentComponent(XmlPullParser xpp, Provenance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Provenance.ProvenanceAgentComponent res = new Provenance.ProvenanceAgentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProvenanceProvenanceAgentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProvenanceProvenanceAgentComponentContent(int eventType, XmlPullParser xpp, Provenance owner, Provenance.ProvenanceAgentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.setRole(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("userId")) {
- res.setUserId(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relatedAgent")) {
- res.getRelatedAgent().add(parseProvenanceProvenanceAgentRelatedAgentComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Provenance.ProvenanceAgentRelatedAgentComponent parseProvenanceProvenanceAgentRelatedAgentComponent(XmlPullParser xpp, Provenance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Provenance.ProvenanceAgentRelatedAgentComponent res = new Provenance.ProvenanceAgentRelatedAgentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProvenanceProvenanceAgentRelatedAgentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProvenanceProvenanceAgentRelatedAgentComponentContent(int eventType, XmlPullParser xpp, Provenance owner, Provenance.ProvenanceAgentRelatedAgentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.setTargetElement(parseUri(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Provenance.ProvenanceEntityComponent parseProvenanceProvenanceEntityComponent(XmlPullParser xpp, Provenance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Provenance.ProvenanceEntityComponent res = new Provenance.ProvenanceEntityComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseProvenanceProvenanceEntityComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseProvenanceProvenanceEntityComponentContent(int eventType, XmlPullParser xpp, Provenance owner, Provenance.ProvenanceEntityComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("role")) {
- res.setRoleElement(parseEnumeration(xpp, Provenance.ProvenanceEntityRole.NULL, new Provenance.ProvenanceEntityRoleEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reference")) {
- res.setReferenceElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("display")) {
- res.setDisplayElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("agent")) {
- res.setAgent(parseProvenanceProvenanceAgentComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Questionnaire parseQuestionnaire(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Questionnaire res = new Questionnaire();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseQuestionnaireContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseQuestionnaireContent(int eventType, XmlPullParser xpp, Questionnaire res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Questionnaire.QuestionnaireStatus.NULL, new Questionnaire.QuestionnaireStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("title")) {
- res.setTitleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("concept")) {
- res.getConcept().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subjectType")) {
- res.getSubjectType().add(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseQuestionnaireQuestionnaireItemComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Questionnaire.QuestionnaireItemComponent parseQuestionnaireQuestionnaireItemComponent(XmlPullParser xpp, Questionnaire owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Questionnaire.QuestionnaireItemComponent res = new Questionnaire.QuestionnaireItemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseQuestionnaireQuestionnaireItemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseQuestionnaireQuestionnaireItemComponentContent(int eventType, XmlPullParser xpp, Questionnaire owner, Questionnaire.QuestionnaireItemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("linkId")) {
- res.setLinkIdElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("concept")) {
- res.getConcept().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prefix")) {
- res.setPrefixElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Questionnaire.QuestionnaireItemType.NULL, new Questionnaire.QuestionnaireItemTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("enableWhen")) {
- res.getEnableWhen().add(parseQuestionnaireQuestionnaireItemEnableWhenComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("required")) {
- res.setRequiredElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("repeats")) {
- res.setRepeatsElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("readOnly")) {
- res.setReadOnlyElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("maxLength")) {
- res.setMaxLengthElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("options")) {
- res.setOptions(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("option")) {
- res.getOption().add(parseQuestionnaireQuestionnaireItemOptionComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "initial")) {
- res.setInitial(parseType("initial", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseQuestionnaireQuestionnaireItemComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Questionnaire.QuestionnaireItemEnableWhenComponent parseQuestionnaireQuestionnaireItemEnableWhenComponent(XmlPullParser xpp, Questionnaire owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Questionnaire.QuestionnaireItemEnableWhenComponent res = new Questionnaire.QuestionnaireItemEnableWhenComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseQuestionnaireQuestionnaireItemEnableWhenComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseQuestionnaireQuestionnaireItemEnableWhenComponentContent(int eventType, XmlPullParser xpp, Questionnaire owner, Questionnaire.QuestionnaireItemEnableWhenComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("question")) {
- res.setQuestionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("hasAnswer")) {
- res.setHasAnswerElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "answer")) {
- res.setAnswer(parseType("answer", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Questionnaire.QuestionnaireItemOptionComponent parseQuestionnaireQuestionnaireItemOptionComponent(XmlPullParser xpp, Questionnaire owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Questionnaire.QuestionnaireItemOptionComponent res = new Questionnaire.QuestionnaireItemOptionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseQuestionnaireQuestionnaireItemOptionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseQuestionnaireQuestionnaireItemOptionComponentContent(int eventType, XmlPullParser xpp, Questionnaire owner, Questionnaire.QuestionnaireItemOptionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected QuestionnaireResponse parseQuestionnaireResponse(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- QuestionnaireResponse res = new QuestionnaireResponse();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseQuestionnaireResponseContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseQuestionnaireResponseContent(int eventType, XmlPullParser xpp, QuestionnaireResponse res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("questionnaire")) {
- res.setQuestionnaire(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, QuestionnaireResponse.QuestionnaireResponseStatus.NULL, new QuestionnaireResponse.QuestionnaireResponseStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("author")) {
- res.setAuthor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("authored")) {
- res.setAuthoredElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("source")) {
- res.setSource(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseQuestionnaireResponseQuestionnaireResponseItemComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected QuestionnaireResponse.QuestionnaireResponseItemComponent parseQuestionnaireResponseQuestionnaireResponseItemComponent(XmlPullParser xpp, QuestionnaireResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- QuestionnaireResponse.QuestionnaireResponseItemComponent res = new QuestionnaireResponse.QuestionnaireResponseItemComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseQuestionnaireResponseQuestionnaireResponseItemComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseQuestionnaireResponseQuestionnaireResponseItemComponentContent(int eventType, XmlPullParser xpp, QuestionnaireResponse owner, QuestionnaireResponse.QuestionnaireResponseItemComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("linkId")) {
- res.setLinkIdElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("text")) {
- res.setTextElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("answer")) {
- res.getAnswer().add(parseQuestionnaireResponseQuestionnaireResponseItemAnswerComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseQuestionnaireResponseQuestionnaireResponseItemComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent parseQuestionnaireResponseQuestionnaireResponseItemAnswerComponent(XmlPullParser xpp, QuestionnaireResponse owner) throws XmlPullParserException, IOException, FHIRFormatError {
- QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent res = new QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseQuestionnaireResponseQuestionnaireResponseItemAnswerComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseQuestionnaireResponseQuestionnaireResponseItemAnswerComponentContent(int eventType, XmlPullParser xpp, QuestionnaireResponse owner, QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("item")) {
- res.getItem().add(parseQuestionnaireResponseQuestionnaireResponseItemComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ReferralRequest parseReferralRequest(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ReferralRequest res = new ReferralRequest();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseReferralRequestContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseReferralRequestContent(int eventType, XmlPullParser xpp, ReferralRequest res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("basedOn")) {
- res.getBasedOn().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parent")) {
- res.setParent(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, ReferralRequest.ReferralStatus.NULL, new ReferralRequest.ReferralStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.setCategoryElement(parseEnumeration(xpp, ReferralRequest.ReferralCategory.NULL, new ReferralRequest.ReferralCategoryEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priority")) {
- res.setPriority(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("context")) {
- res.setContext(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fulfillmentTime")) {
- res.setFulfillmentTime(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("authored")) {
- res.setAuthoredElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requester")) {
- res.setRequester(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specialty")) {
- res.setSpecialty(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recipient")) {
- res.getRecipient().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceRequested")) {
- res.getServiceRequested().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supportingInformation")) {
- res.getSupportingInformation().add(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected RelatedPerson parseRelatedPerson(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- RelatedPerson res = new RelatedPerson();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseRelatedPersonContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseRelatedPersonContent(int eventType, XmlPullParser xpp, RelatedPerson res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relationship")) {
- res.setRelationship(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setName(parseHumanName(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("gender")) {
- res.setGenderElement(parseEnumeration(xpp, Enumerations.AdministrativeGender.NULL, new Enumerations.AdministrativeGenderEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("birthDate")) {
- res.setBirthDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("address")) {
- res.getAddress().add(parseAddress(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("photo")) {
- res.getPhoto().add(parseAttachment(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected RiskAssessment parseRiskAssessment(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- RiskAssessment res = new RiskAssessment();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseRiskAssessmentContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseRiskAssessmentContent(int eventType, XmlPullParser xpp, RiskAssessment res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("condition")) {
- res.setCondition(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("performer")) {
- res.setPerformer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("method")) {
- res.setMethod(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("basis")) {
- res.getBasis().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prediction")) {
- res.getPrediction().add(parseRiskAssessmentRiskAssessmentPredictionComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mitigation")) {
- res.setMitigationElement(parseString(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected RiskAssessment.RiskAssessmentPredictionComponent parseRiskAssessmentRiskAssessmentPredictionComponent(XmlPullParser xpp, RiskAssessment owner) throws XmlPullParserException, IOException, FHIRFormatError {
- RiskAssessment.RiskAssessmentPredictionComponent res = new RiskAssessment.RiskAssessmentPredictionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseRiskAssessmentRiskAssessmentPredictionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseRiskAssessmentRiskAssessmentPredictionComponentContent(int eventType, XmlPullParser xpp, RiskAssessment owner, RiskAssessment.RiskAssessmentPredictionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outcome")) {
- res.setOutcome(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "probability")) {
- res.setProbability(parseType("probability", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("relativeRisk")) {
- res.setRelativeRiskElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "when")) {
- res.setWhen(parseType("when", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rationale")) {
- res.setRationaleElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Schedule parseSchedule(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Schedule res = new Schedule();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseScheduleContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseScheduleContent(int eventType, XmlPullParser xpp, Schedule res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceCategory")) {
- res.setServiceCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceType")) {
- res.getServiceType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specialty")) {
- res.getSpecialty().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("actor")) {
- res.setActor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("planningHorizon")) {
- res.setPlanningHorizon(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comment")) {
- res.setCommentElement(parseString(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected SearchParameter parseSearchParameter(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- SearchParameter res = new SearchParameter();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSearchParameterContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSearchParameterContent(int eventType, XmlPullParser xpp, SearchParameter res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseSearchParameterSearchParameterContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("base")) {
- res.setBaseElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Enumerations.SearchParamType.NULL, new Enumerations.SearchParamTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("expression")) {
- res.setExpressionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("xpath")) {
- res.setXpathElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("xpathUsage")) {
- res.setXpathUsageElement(parseEnumeration(xpp, SearchParameter.XPathUsageType.NULL, new SearchParameter.XPathUsageTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.getTarget().add(parseCode(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected SearchParameter.SearchParameterContactComponent parseSearchParameterSearchParameterContactComponent(XmlPullParser xpp, SearchParameter owner) throws XmlPullParserException, IOException, FHIRFormatError {
- SearchParameter.SearchParameterContactComponent res = new SearchParameter.SearchParameterContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSearchParameterSearchParameterContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSearchParameterSearchParameterContactComponentContent(int eventType, XmlPullParser xpp, SearchParameter owner, SearchParameter.SearchParameterContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Sequence parseSequence(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Sequence res = new Sequence();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSequenceContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSequenceContent(int eventType, XmlPullParser xpp, Sequence res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Sequence.SequenceType.NULL, new Sequence.SequenceTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("coordinateSystem")) {
- res.setCoordinateSystemElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specimen")) {
- res.setSpecimen(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("device")) {
- res.setDevice(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("referenceSeq")) {
- res.setReferenceSeq(parseSequenceSequenceReferenceSeqComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("variant")) {
- res.getVariant().add(parseSequenceSequenceVariantComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("observedSeq")) {
- res.setObservedSeqElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quality")) {
- res.getQuality().add(parseSequenceSequenceQualityComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("readCoverage")) {
- res.setReadCoverageElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("repository")) {
- res.getRepository().add(parseSequenceSequenceRepositoryComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("pointer")) {
- res.getPointer().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("structureVariant")) {
- res.setStructureVariant(parseSequenceSequenceStructureVariantComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Sequence.SequenceReferenceSeqComponent parseSequenceSequenceReferenceSeqComponent(XmlPullParser xpp, Sequence owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Sequence.SequenceReferenceSeqComponent res = new Sequence.SequenceReferenceSeqComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSequenceSequenceReferenceSeqComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSequenceSequenceReferenceSeqComponentContent(int eventType, XmlPullParser xpp, Sequence owner, Sequence.SequenceReferenceSeqComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("chromosome")) {
- res.setChromosome(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("genomeBuild")) {
- res.setGenomeBuildElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("referenceSeqId")) {
- res.setReferenceSeqId(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("referenceSeqPointer")) {
- res.setReferenceSeqPointer(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("referenceSeqString")) {
- res.setReferenceSeqStringElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("strand")) {
- res.setStrandElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("windowStart")) {
- res.setWindowStartElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("windowEnd")) {
- res.setWindowEndElement(parseInteger(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Sequence.SequenceVariantComponent parseSequenceSequenceVariantComponent(XmlPullParser xpp, Sequence owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Sequence.SequenceVariantComponent res = new Sequence.SequenceVariantComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSequenceSequenceVariantComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSequenceSequenceVariantComponentContent(int eventType, XmlPullParser xpp, Sequence owner, Sequence.SequenceVariantComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("start")) {
- res.setStartElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("end")) {
- res.setEndElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("observedAllele")) {
- res.setObservedAlleleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("referenceAllele")) {
- res.setReferenceAlleleElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("cigar")) {
- res.setCigarElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Sequence.SequenceQualityComponent parseSequenceSequenceQualityComponent(XmlPullParser xpp, Sequence owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Sequence.SequenceQualityComponent res = new Sequence.SequenceQualityComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSequenceSequenceQualityComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSequenceSequenceQualityComponentContent(int eventType, XmlPullParser xpp, Sequence owner, Sequence.SequenceQualityComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("start")) {
- res.setStartElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("end")) {
- res.setEndElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("score")) {
- res.setScore(parseQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("method")) {
- res.setMethodElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("truePositives")) {
- res.setTruePositivesElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("falsePositives")) {
- res.setFalsePositivesElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("falseNegatives")) {
- res.setFalseNegativesElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("precision")) {
- res.setPrecisionElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recall")) {
- res.setRecallElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fMeasure")) {
- res.setFMeasureElement(parseDecimal(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Sequence.SequenceRepositoryComponent parseSequenceSequenceRepositoryComponent(XmlPullParser xpp, Sequence owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Sequence.SequenceRepositoryComponent res = new Sequence.SequenceRepositoryComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSequenceSequenceRepositoryComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSequenceSequenceRepositoryComponentContent(int eventType, XmlPullParser xpp, Sequence owner, Sequence.SequenceRepositoryComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("variantId")) {
- res.setVariantIdElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("readId")) {
- res.setReadIdElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Sequence.SequenceStructureVariantComponent parseSequenceSequenceStructureVariantComponent(XmlPullParser xpp, Sequence owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Sequence.SequenceStructureVariantComponent res = new Sequence.SequenceStructureVariantComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSequenceSequenceStructureVariantComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSequenceSequenceStructureVariantComponentContent(int eventType, XmlPullParser xpp, Sequence owner, Sequence.SequenceStructureVariantComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("precisionOfBoundaries")) {
- res.setPrecisionOfBoundariesElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reportedaCGHRatio")) {
- res.setReportedaCGHRatioElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("length")) {
- res.setLengthElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("outer")) {
- res.setOuter(parseSequenceSequenceStructureVariantOuterComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("inner")) {
- res.setInner(parseSequenceSequenceStructureVariantInnerComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Sequence.SequenceStructureVariantOuterComponent parseSequenceSequenceStructureVariantOuterComponent(XmlPullParser xpp, Sequence owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Sequence.SequenceStructureVariantOuterComponent res = new Sequence.SequenceStructureVariantOuterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSequenceSequenceStructureVariantOuterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSequenceSequenceStructureVariantOuterComponentContent(int eventType, XmlPullParser xpp, Sequence owner, Sequence.SequenceStructureVariantOuterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("start")) {
- res.setStartElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("end")) {
- res.setEndElement(parseInteger(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Sequence.SequenceStructureVariantInnerComponent parseSequenceSequenceStructureVariantInnerComponent(XmlPullParser xpp, Sequence owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Sequence.SequenceStructureVariantInnerComponent res = new Sequence.SequenceStructureVariantInnerComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSequenceSequenceStructureVariantInnerComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSequenceSequenceStructureVariantInnerComponentContent(int eventType, XmlPullParser xpp, Sequence owner, Sequence.SequenceStructureVariantInnerComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("start")) {
- res.setStartElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("end")) {
- res.setEndElement(parseInteger(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Slot parseSlot(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Slot res = new Slot();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSlotContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSlotContent(int eventType, XmlPullParser xpp, Slot res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceCategory")) {
- res.setServiceCategory(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("serviceType")) {
- res.getServiceType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specialty")) {
- res.getSpecialty().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("appointmentType")) {
- res.setAppointmentType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("schedule")) {
- res.setSchedule(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Slot.SlotStatus.NULL, new Slot.SlotStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("start")) {
- res.setStartElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("end")) {
- res.setEndElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("overbooked")) {
- res.setOverbookedElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comment")) {
- res.setCommentElement(parseString(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Specimen parseSpecimen(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Specimen res = new Specimen();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSpecimenContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSpecimenContent(int eventType, XmlPullParser xpp, Specimen res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("accessionIdentifier")) {
- res.setAccessionIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Specimen.SpecimenStatus.NULL, new Specimen.SpecimenStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("subject")) {
- res.setSubject(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("receivedTime")) {
- res.setReceivedTimeElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parent")) {
- res.getParent().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("request")) {
- res.getRequest().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("collection")) {
- res.setCollection(parseSpecimenSpecimenCollectionComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("treatment")) {
- res.getTreatment().add(parseSpecimenSpecimenTreatmentComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("container")) {
- res.getContainer().add(parseSpecimenSpecimenContainerComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Specimen.SpecimenCollectionComponent parseSpecimenSpecimenCollectionComponent(XmlPullParser xpp, Specimen owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Specimen.SpecimenCollectionComponent res = new Specimen.SpecimenCollectionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSpecimenSpecimenCollectionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSpecimenSpecimenCollectionComponentContent(int eventType, XmlPullParser xpp, Specimen owner, Specimen.SpecimenCollectionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("collector")) {
- res.setCollector(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "collected")) {
- res.setCollected(parseType("collected", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("method")) {
- res.setMethod(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("bodySite")) {
- res.setBodySite(parseCodeableConcept(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Specimen.SpecimenTreatmentComponent parseSpecimenSpecimenTreatmentComponent(XmlPullParser xpp, Specimen owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Specimen.SpecimenTreatmentComponent res = new Specimen.SpecimenTreatmentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSpecimenSpecimenTreatmentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSpecimenSpecimenTreatmentComponentContent(int eventType, XmlPullParser xpp, Specimen owner, Specimen.SpecimenTreatmentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("procedure")) {
- res.setProcedure(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("additive")) {
- res.getAdditive().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "time")) {
- res.setTime(parseType("time", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Specimen.SpecimenContainerComponent parseSpecimenSpecimenContainerComponent(XmlPullParser xpp, Specimen owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Specimen.SpecimenContainerComponent res = new Specimen.SpecimenContainerComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSpecimenSpecimenContainerComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSpecimenSpecimenContainerComponentContent(int eventType, XmlPullParser xpp, Specimen owner, Specimen.SpecimenContainerComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("capacity")) {
- res.setCapacity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("specimenQuantity")) {
- res.setSpecimenQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "additive")) {
- res.setAdditive(parseType("additive", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureDefinition parseStructureDefinition(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureDefinition res = new StructureDefinition();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureDefinitionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureDefinitionContent(int eventType, XmlPullParser xpp, StructureDefinition res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("display")) {
- res.setDisplayElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseStructureDefinitionStructureDefinitionContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("copyright")) {
- res.setCopyrightElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.getCode().add(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fhirVersion")) {
- res.setFhirVersionElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mapping")) {
- res.getMapping().add(parseStructureDefinitionStructureDefinitionMappingComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("kind")) {
- res.setKindElement(parseEnumeration(xpp, StructureDefinition.StructureDefinitionKind.NULL, new StructureDefinition.StructureDefinitionKindEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("abstract")) {
- res.setAbstractElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contextType")) {
- res.setContextTypeElement(parseEnumeration(xpp, StructureDefinition.ExtensionContext.NULL, new StructureDefinition.ExtensionContextEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("context")) {
- res.getContext().add(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("baseType")) {
- res.setBaseTypeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("baseDefinition")) {
- res.setBaseDefinitionElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("derivation")) {
- res.setDerivationElement(parseEnumeration(xpp, StructureDefinition.TypeDerivationRule.NULL, new StructureDefinition.TypeDerivationRuleEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("snapshot")) {
- res.setSnapshot(parseStructureDefinitionStructureDefinitionSnapshotComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("differential")) {
- res.setDifferential(parseStructureDefinitionStructureDefinitionDifferentialComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureDefinition.StructureDefinitionContactComponent parseStructureDefinitionStructureDefinitionContactComponent(XmlPullParser xpp, StructureDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureDefinition.StructureDefinitionContactComponent res = new StructureDefinition.StructureDefinitionContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureDefinitionStructureDefinitionContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureDefinitionStructureDefinitionContactComponentContent(int eventType, XmlPullParser xpp, StructureDefinition owner, StructureDefinition.StructureDefinitionContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureDefinition.StructureDefinitionMappingComponent parseStructureDefinitionStructureDefinitionMappingComponent(XmlPullParser xpp, StructureDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureDefinition.StructureDefinitionMappingComponent res = new StructureDefinition.StructureDefinitionMappingComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureDefinitionStructureDefinitionMappingComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureDefinitionStructureDefinitionMappingComponentContent(int eventType, XmlPullParser xpp, StructureDefinition owner, StructureDefinition.StructureDefinitionMappingComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identity")) {
- res.setIdentityElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("uri")) {
- res.setUriElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("comments")) {
- res.setCommentsElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureDefinition.StructureDefinitionSnapshotComponent parseStructureDefinitionStructureDefinitionSnapshotComponent(XmlPullParser xpp, StructureDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureDefinition.StructureDefinitionSnapshotComponent res = new StructureDefinition.StructureDefinitionSnapshotComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureDefinitionStructureDefinitionSnapshotComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureDefinitionStructureDefinitionSnapshotComponentContent(int eventType, XmlPullParser xpp, StructureDefinition owner, StructureDefinition.StructureDefinitionSnapshotComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("element")) {
- res.getElement().add(parseElementDefinition(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureDefinition.StructureDefinitionDifferentialComponent parseStructureDefinitionStructureDefinitionDifferentialComponent(XmlPullParser xpp, StructureDefinition owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureDefinition.StructureDefinitionDifferentialComponent res = new StructureDefinition.StructureDefinitionDifferentialComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureDefinitionStructureDefinitionDifferentialComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureDefinitionStructureDefinitionDifferentialComponentContent(int eventType, XmlPullParser xpp, StructureDefinition owner, StructureDefinition.StructureDefinitionDifferentialComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("element")) {
- res.getElement().add(parseElementDefinition(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureMap parseStructureMap(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureMap res = new StructureMap();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureMapContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureMapContent(int eventType, XmlPullParser xpp, StructureMap res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseStructureMapStructureMapContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("copyright")) {
- res.setCopyrightElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("structure")) {
- res.getStructure().add(parseStructureMapStructureMapStructureComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("import")) {
- res.getImport().add(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("group")) {
- res.getGroup().add(parseStructureMapStructureMapGroupComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureMap.StructureMapContactComponent parseStructureMapStructureMapContactComponent(XmlPullParser xpp, StructureMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureMap.StructureMapContactComponent res = new StructureMap.StructureMapContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureMapStructureMapContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureMapStructureMapContactComponentContent(int eventType, XmlPullParser xpp, StructureMap owner, StructureMap.StructureMapContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureMap.StructureMapStructureComponent parseStructureMapStructureMapStructureComponent(XmlPullParser xpp, StructureMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureMap.StructureMapStructureComponent res = new StructureMap.StructureMapStructureComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureMapStructureMapStructureComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureMapStructureMapStructureComponentContent(int eventType, XmlPullParser xpp, StructureMap owner, StructureMap.StructureMapStructureComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mode")) {
- res.setModeElement(parseEnumeration(xpp, StructureMap.StructureMapModelMode.NULL, new StructureMap.StructureMapModelModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureMap.StructureMapGroupComponent parseStructureMapStructureMapGroupComponent(XmlPullParser xpp, StructureMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureMap.StructureMapGroupComponent res = new StructureMap.StructureMapGroupComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureMapStructureMapGroupComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureMapStructureMapGroupComponentContent(int eventType, XmlPullParser xpp, StructureMap owner, StructureMap.StructureMapGroupComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("extends")) {
- res.setExtendsElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("input")) {
- res.getInput().add(parseStructureMapStructureMapGroupInputComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rule")) {
- res.getRule().add(parseStructureMapStructureMapGroupRuleComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureMap.StructureMapGroupInputComponent parseStructureMapStructureMapGroupInputComponent(XmlPullParser xpp, StructureMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureMap.StructureMapGroupInputComponent res = new StructureMap.StructureMapGroupInputComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureMapStructureMapGroupInputComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureMapStructureMapGroupInputComponentContent(int eventType, XmlPullParser xpp, StructureMap owner, StructureMap.StructureMapGroupInputComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("mode")) {
- res.setModeElement(parseEnumeration(xpp, StructureMap.StructureMapInputMode.NULL, new StructureMap.StructureMapInputModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureMap.StructureMapGroupRuleComponent parseStructureMapStructureMapGroupRuleComponent(XmlPullParser xpp, StructureMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureMap.StructureMapGroupRuleComponent res = new StructureMap.StructureMapGroupRuleComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureMapStructureMapGroupRuleComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureMapStructureMapGroupRuleComponentContent(int eventType, XmlPullParser xpp, StructureMap owner, StructureMap.StructureMapGroupRuleComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("source")) {
- res.getSource().add(parseStructureMapStructureMapGroupRuleSourceComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("target")) {
- res.getTarget().add(parseStructureMapStructureMapGroupRuleTargetComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rule")) {
- res.getRule().add(parseStructureMapStructureMapGroupRuleComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dependent")) {
- res.getDependent().add(parseStructureMapStructureMapGroupRuleDependentComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("documentation")) {
- res.setDocumentationElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureMap.StructureMapGroupRuleSourceComponent parseStructureMapStructureMapGroupRuleSourceComponent(XmlPullParser xpp, StructureMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureMap.StructureMapGroupRuleSourceComponent res = new StructureMap.StructureMapGroupRuleSourceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureMapStructureMapGroupRuleSourceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureMapStructureMapGroupRuleSourceComponentContent(int eventType, XmlPullParser xpp, StructureMap owner, StructureMap.StructureMapGroupRuleSourceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("required")) {
- res.setRequiredElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("context")) {
- res.setContextElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contextType")) {
- res.setContextTypeElement(parseEnumeration(xpp, StructureMap.StructureMapContextType.NULL, new StructureMap.StructureMapContextTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("element")) {
- res.setElementElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("listMode")) {
- res.setListModeElement(parseEnumeration(xpp, StructureMap.StructureMapListMode.NULL, new StructureMap.StructureMapListModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("variable")) {
- res.setVariableElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("condition")) {
- res.setConditionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("check")) {
- res.setCheckElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureMap.StructureMapGroupRuleTargetComponent parseStructureMapStructureMapGroupRuleTargetComponent(XmlPullParser xpp, StructureMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureMap.StructureMapGroupRuleTargetComponent res = new StructureMap.StructureMapGroupRuleTargetComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureMapStructureMapGroupRuleTargetComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureMapStructureMapGroupRuleTargetComponentContent(int eventType, XmlPullParser xpp, StructureMap owner, StructureMap.StructureMapGroupRuleTargetComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("context")) {
- res.setContextElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contextType")) {
- res.setContextTypeElement(parseEnumeration(xpp, StructureMap.StructureMapContextType.NULL, new StructureMap.StructureMapContextTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("element")) {
- res.setElementElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("variable")) {
- res.setVariableElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("listMode")) {
- res.getListMode().add(parseEnumeration(xpp, StructureMap.StructureMapListMode.NULL, new StructureMap.StructureMapListModeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("listRuleId")) {
- res.setListRuleIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("transform")) {
- res.setTransformElement(parseEnumeration(xpp, StructureMap.StructureMapTransform.NULL, new StructureMap.StructureMapTransformEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parameter")) {
- res.getParameter().add(parseStructureMapStructureMapGroupRuleTargetParameterComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureMap.StructureMapGroupRuleTargetParameterComponent parseStructureMapStructureMapGroupRuleTargetParameterComponent(XmlPullParser xpp, StructureMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureMap.StructureMapGroupRuleTargetParameterComponent res = new StructureMap.StructureMapGroupRuleTargetParameterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureMapStructureMapGroupRuleTargetParameterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureMapStructureMapGroupRuleTargetParameterComponentContent(int eventType, XmlPullParser xpp, StructureMap owner, StructureMap.StructureMapGroupRuleTargetParameterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected StructureMap.StructureMapGroupRuleDependentComponent parseStructureMapStructureMapGroupRuleDependentComponent(XmlPullParser xpp, StructureMap owner) throws XmlPullParserException, IOException, FHIRFormatError {
- StructureMap.StructureMapGroupRuleDependentComponent res = new StructureMap.StructureMapGroupRuleDependentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseStructureMapStructureMapGroupRuleDependentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseStructureMapStructureMapGroupRuleDependentComponentContent(int eventType, XmlPullParser xpp, StructureMap owner, StructureMap.StructureMapGroupRuleDependentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("variable")) {
- res.getVariable().add(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Subscription parseSubscription(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Subscription res = new Subscription();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSubscriptionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSubscriptionContent(int eventType, XmlPullParser xpp, Subscription res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("criteria")) {
- res.setCriteriaElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseContactPoint(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReasonElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Subscription.SubscriptionStatus.NULL, new Subscription.SubscriptionStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("error")) {
- res.setErrorElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("channel")) {
- res.setChannel(parseSubscriptionSubscriptionChannelComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("end")) {
- res.setEndElement(parseInstant(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("tag")) {
- res.getTag().add(parseCoding(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Subscription.SubscriptionChannelComponent parseSubscriptionSubscriptionChannelComponent(XmlPullParser xpp, Subscription owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Subscription.SubscriptionChannelComponent res = new Subscription.SubscriptionChannelComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSubscriptionSubscriptionChannelComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSubscriptionSubscriptionChannelComponentContent(int eventType, XmlPullParser xpp, Subscription owner, Subscription.SubscriptionChannelComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setTypeElement(parseEnumeration(xpp, Subscription.SubscriptionChannelType.NULL, new Subscription.SubscriptionChannelTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("endpoint")) {
- res.setEndpointElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("payload")) {
- res.setPayloadElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("header")) {
- res.setHeaderElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Substance parseSubstance(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Substance res = new Substance();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSubstanceContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSubstanceContent(int eventType, XmlPullParser xpp, Substance res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("category")) {
- res.getCategory().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("instance")) {
- res.getInstance().add(parseSubstanceSubstanceInstanceComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ingredient")) {
- res.getIngredient().add(parseSubstanceSubstanceIngredientComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Substance.SubstanceInstanceComponent parseSubstanceSubstanceInstanceComponent(XmlPullParser xpp, Substance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Substance.SubstanceInstanceComponent res = new Substance.SubstanceInstanceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSubstanceSubstanceInstanceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSubstanceSubstanceInstanceComponentContent(int eventType, XmlPullParser xpp, Substance owner, Substance.SubstanceInstanceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("expiry")) {
- res.setExpiryElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Substance.SubstanceIngredientComponent parseSubstanceSubstanceIngredientComponent(XmlPullParser xpp, Substance owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Substance.SubstanceIngredientComponent res = new Substance.SubstanceIngredientComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSubstanceSubstanceIngredientComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSubstanceSubstanceIngredientComponentContent(int eventType, XmlPullParser xpp, Substance owner, Substance.SubstanceIngredientComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseRatio(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "substance")) {
- res.setSubstance(parseType("substance", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected SupplyDelivery parseSupplyDelivery(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- SupplyDelivery res = new SupplyDelivery();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSupplyDeliveryContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSupplyDeliveryContent(int eventType, XmlPullParser xpp, SupplyDelivery res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, SupplyDelivery.SupplyDeliveryStatus.NULL, new SupplyDelivery.SupplyDeliveryStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("quantity")) {
- res.setQuantity(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "suppliedItem")) {
- res.setSuppliedItem(parseType("suppliedItem", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supplier")) {
- res.setSupplier(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("whenPrepared")) {
- res.setWhenPrepared(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("time")) {
- res.setTimeElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("destination")) {
- res.setDestination(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("receiver")) {
- res.getReceiver().add(parseReference(xpp));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected SupplyRequest parseSupplyRequest(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- SupplyRequest res = new SupplyRequest();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSupplyRequestContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSupplyRequestContent(int eventType, XmlPullParser xpp, SupplyRequest res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("source")) {
- res.setSource(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, SupplyRequest.SupplyRequestStatus.NULL, new SupplyRequest.SupplyRequestStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("kind")) {
- res.setKind(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "orderedItem")) {
- res.setOrderedItem(parseType("orderedItem", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("supplier")) {
- res.getSupplier().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "reason")) {
- res.setReason(parseType("reason", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("when")) {
- res.setWhen(parseSupplyRequestSupplyRequestWhenComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected SupplyRequest.SupplyRequestWhenComponent parseSupplyRequestSupplyRequestWhenComponent(XmlPullParser xpp, SupplyRequest owner) throws XmlPullParserException, IOException, FHIRFormatError {
- SupplyRequest.SupplyRequestWhenComponent res = new SupplyRequest.SupplyRequestWhenComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseSupplyRequestSupplyRequestWhenComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseSupplyRequestSupplyRequestWhenComponentContent(int eventType, XmlPullParser xpp, SupplyRequest owner, SupplyRequest.SupplyRequestWhenComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("schedule")) {
- res.setSchedule(parseTiming(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Task parseTask(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- Task res = new Task();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTaskContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTaskContent(int eventType, XmlPullParser xpp, Task res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("basedOn")) {
- res.getBasedOn().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requisition")) {
- res.setRequisition(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parent")) {
- res.getParent().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Task.TaskStatus.NULL, new Task.TaskStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("statusReason")) {
- res.setStatusReason(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("businessStatus")) {
- res.setBusinessStatus(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("stage")) {
- res.setStage(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCode(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("priority")) {
- res.setPriorityElement(parseEnumeration(xpp, Task.TaskPriority.NULL, new Task.TaskPriorityEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("focus")) {
- res.setFocus(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("for")) {
- res.setFor(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("context")) {
- res.setContext(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("created")) {
- res.setCreatedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lastModified")) {
- res.setLastModifiedElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requester")) {
- res.setRequester(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("owner")) {
- res.setOwner(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("performerType")) {
- res.getPerformerType().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("reason")) {
- res.setReason(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("note")) {
- res.getNote().add(parseAnnotation(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fulfillment")) {
- res.setFulfillment(parseTaskTaskFulfillmentComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("definition")) {
- res.setDefinitionElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("input")) {
- res.getInput().add(parseTaskParameterComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("output")) {
- res.getOutput().add(parseTaskTaskOutputComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Task.TaskFulfillmentComponent parseTaskTaskFulfillmentComponent(XmlPullParser xpp, Task owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Task.TaskFulfillmentComponent res = new Task.TaskFulfillmentComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTaskTaskFulfillmentComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTaskTaskFulfillmentComponentContent(int eventType, XmlPullParser xpp, Task owner, Task.TaskFulfillmentComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("repetitions")) {
- res.setRepetitionsElement(parsePositiveInt(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("period")) {
- res.setPeriod(parsePeriod(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("recipients")) {
- res.getRecipients().add(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Task.ParameterComponent parseTaskParameterComponent(XmlPullParser xpp, Task owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Task.ParameterComponent res = new Task.ParameterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTaskParameterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTaskParameterComponentContent(int eventType, XmlPullParser xpp, Task owner, Task.ParameterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected Task.TaskOutputComponent parseTaskTaskOutputComponent(XmlPullParser xpp, Task owner) throws XmlPullParserException, IOException, FHIRFormatError {
- Task.TaskOutputComponent res = new Task.TaskOutputComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTaskTaskOutputComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTaskTaskOutputComponentContent(int eventType, XmlPullParser xpp, Task owner, Task.TaskOutputComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript parseTestScript(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript res = new TestScript();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptContent(int eventType, XmlPullParser xpp, TestScript res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseTestScriptTestScriptContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("copyright")) {
- res.setCopyrightElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("origin")) {
- res.getOrigin().add(parseTestScriptTestScriptOriginComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("destination")) {
- res.getDestination().add(parseTestScriptTestScriptDestinationComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("metadata")) {
- res.setMetadata(parseTestScriptTestScriptMetadataComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("fixture")) {
- res.getFixture().add(parseTestScriptTestScriptFixtureComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.getProfile().add(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("variable")) {
- res.getVariable().add(parseTestScriptTestScriptVariableComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rule")) {
- res.getRule().add(parseTestScriptTestScriptRuleComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.getRuleset().add(parseTestScriptTestScriptRulesetComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("setup")) {
- res.setSetup(parseTestScriptTestScriptSetupComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("test")) {
- res.getTest().add(parseTestScriptTestScriptTestComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("teardown")) {
- res.setTeardown(parseTestScriptTestScriptTeardownComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptContactComponent parseTestScriptTestScriptContactComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptContactComponent res = new TestScript.TestScriptContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptContactComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptOriginComponent parseTestScriptTestScriptOriginComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptOriginComponent res = new TestScript.TestScriptOriginComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptOriginComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptOriginComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptOriginComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("index")) {
- res.setIndexElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.setProfile(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptDestinationComponent parseTestScriptTestScriptDestinationComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptDestinationComponent res = new TestScript.TestScriptDestinationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptDestinationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptDestinationComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptDestinationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("index")) {
- res.setIndexElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("profile")) {
- res.setProfile(parseCoding(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptMetadataComponent parseTestScriptTestScriptMetadataComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptMetadataComponent res = new TestScript.TestScriptMetadataComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptMetadataComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptMetadataComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptMetadataComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("link")) {
- res.getLink().add(parseTestScriptTestScriptMetadataLinkComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("capability")) {
- res.getCapability().add(parseTestScriptTestScriptMetadataCapabilityComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptMetadataLinkComponent parseTestScriptTestScriptMetadataLinkComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptMetadataLinkComponent res = new TestScript.TestScriptMetadataLinkComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptMetadataLinkComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptMetadataLinkComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptMetadataLinkComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptMetadataCapabilityComponent parseTestScriptTestScriptMetadataCapabilityComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptMetadataCapabilityComponent res = new TestScript.TestScriptMetadataCapabilityComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptMetadataCapabilityComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptMetadataCapabilityComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptMetadataCapabilityComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("required")) {
- res.setRequiredElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("validated")) {
- res.setValidatedElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("origin")) {
- res.getOrigin().add(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("destination")) {
- res.setDestinationElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("link")) {
- res.getLink().add(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("conformance")) {
- res.setConformance(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptFixtureComponent parseTestScriptTestScriptFixtureComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptFixtureComponent res = new TestScript.TestScriptFixtureComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptFixtureComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptFixtureComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptFixtureComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("autocreate")) {
- res.setAutocreateElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("autodelete")) {
- res.setAutodeleteElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.setResource(parseReference(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptVariableComponent parseTestScriptTestScriptVariableComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptVariableComponent res = new TestScript.TestScriptVariableComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptVariableComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptVariableComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptVariableComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("defaultValue")) {
- res.setDefaultValueElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("headerField")) {
- res.setHeaderFieldElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("path")) {
- res.setPathElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sourceId")) {
- res.setSourceIdElement(parseId(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptRuleComponent parseTestScriptTestScriptRuleComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptRuleComponent res = new TestScript.TestScriptRuleComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptRuleComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptRuleComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptRuleComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.setResource(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("param")) {
- res.getParam().add(parseTestScriptTestScriptRuleParamComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptRuleParamComponent parseTestScriptTestScriptRuleParamComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptRuleParamComponent res = new TestScript.TestScriptRuleParamComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptRuleParamComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptRuleParamComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptRuleParamComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptRulesetComponent parseTestScriptTestScriptRulesetComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptRulesetComponent res = new TestScript.TestScriptRulesetComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptRulesetComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptRulesetComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptRulesetComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.setResource(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rule")) {
- res.getRule().add(parseTestScriptTestScriptRulesetRuleComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptRulesetRuleComponent parseTestScriptTestScriptRulesetRuleComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptRulesetRuleComponent res = new TestScript.TestScriptRulesetRuleComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptRulesetRuleComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptRulesetRuleComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptRulesetRuleComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleId")) {
- res.setRuleIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("param")) {
- res.getParam().add(parseTestScriptTestScriptRulesetRuleParamComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptRulesetRuleParamComponent parseTestScriptTestScriptRulesetRuleParamComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptRulesetRuleParamComponent res = new TestScript.TestScriptRulesetRuleParamComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptRulesetRuleParamComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptRulesetRuleParamComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptRulesetRuleParamComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptSetupComponent parseTestScriptTestScriptSetupComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptSetupComponent res = new TestScript.TestScriptSetupComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptSetupComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptSetupComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptSetupComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("metadata")) {
- res.setMetadata(parseTestScriptTestScriptMetadataComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseTestScriptSetupActionComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.SetupActionComponent parseTestScriptSetupActionComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.SetupActionComponent res = new TestScript.SetupActionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptSetupActionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptSetupActionComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.SetupActionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("operation")) {
- res.setOperation(parseTestScriptSetupActionOperationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("assert")) {
- res.setAssert(parseTestScriptSetupActionAssertComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.SetupActionOperationComponent parseTestScriptSetupActionOperationComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.SetupActionOperationComponent res = new TestScript.SetupActionOperationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptSetupActionOperationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptSetupActionOperationComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.SetupActionOperationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("type")) {
- res.setType(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.setResourceElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("label")) {
- res.setLabelElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("accept")) {
- res.setAcceptElement(parseEnumeration(xpp, TestScript.ContentType.NULL, new TestScript.ContentTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contentType")) {
- res.setContentTypeElement(parseEnumeration(xpp, TestScript.ContentType.NULL, new TestScript.ContentTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("destination")) {
- res.setDestinationElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encodeRequestUrl")) {
- res.setEncodeRequestUrlElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("origin")) {
- res.setOriginElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("params")) {
- res.setParamsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requestHeader")) {
- res.getRequestHeader().add(parseTestScriptSetupActionOperationRequestHeaderComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("responseId")) {
- res.setResponseIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sourceId")) {
- res.setSourceIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("targetId")) {
- res.setTargetIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.SetupActionOperationRequestHeaderComponent parseTestScriptSetupActionOperationRequestHeaderComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.SetupActionOperationRequestHeaderComponent res = new TestScript.SetupActionOperationRequestHeaderComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptSetupActionOperationRequestHeaderComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptSetupActionOperationRequestHeaderComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.SetupActionOperationRequestHeaderComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("field")) {
- res.setFieldElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.SetupActionAssertComponent parseTestScriptSetupActionAssertComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.SetupActionAssertComponent res = new TestScript.SetupActionAssertComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptSetupActionAssertComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptSetupActionAssertComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.SetupActionAssertComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("label")) {
- res.setLabelElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("direction")) {
- res.setDirectionElement(parseEnumeration(xpp, TestScript.AssertionDirectionType.NULL, new TestScript.AssertionDirectionTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("compareToSourceId")) {
- res.setCompareToSourceIdElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("compareToSourcePath")) {
- res.setCompareToSourcePathElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contentType")) {
- res.setContentTypeElement(parseEnumeration(xpp, TestScript.ContentType.NULL, new TestScript.ContentTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("headerField")) {
- res.setHeaderFieldElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("minimumId")) {
- res.setMinimumIdElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("navigationLinks")) {
- res.setNavigationLinksElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("operator")) {
- res.setOperatorElement(parseEnumeration(xpp, TestScript.AssertionOperatorType.NULL, new TestScript.AssertionOperatorTypeEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("path")) {
- res.setPathElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("resource")) {
- res.setResourceElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("response")) {
- res.setResponseElement(parseEnumeration(xpp, TestScript.AssertionResponseTypes.NULL, new TestScript.AssertionResponseTypesEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("responseCode")) {
- res.setResponseCodeElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rule")) {
- res.setRule(parseTestScriptSetupActionAssertRuleComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleset")) {
- res.setRuleset(parseTestScriptSetupActionAssertRulesetComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sourceId")) {
- res.setSourceIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("validateProfileId")) {
- res.setValidateProfileIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("warningOnly")) {
- res.setWarningOnlyElement(parseBoolean(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.SetupActionAssertRuleComponent parseTestScriptSetupActionAssertRuleComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.SetupActionAssertRuleComponent res = new TestScript.SetupActionAssertRuleComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptSetupActionAssertRuleComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptSetupActionAssertRuleComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.SetupActionAssertRuleComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleId")) {
- res.setRuleIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("param")) {
- res.getParam().add(parseTestScriptSetupActionAssertRuleParamComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.SetupActionAssertRuleParamComponent parseTestScriptSetupActionAssertRuleParamComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.SetupActionAssertRuleParamComponent res = new TestScript.SetupActionAssertRuleParamComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptSetupActionAssertRuleParamComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptSetupActionAssertRuleParamComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.SetupActionAssertRuleParamComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.SetupActionAssertRulesetComponent parseTestScriptSetupActionAssertRulesetComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.SetupActionAssertRulesetComponent res = new TestScript.SetupActionAssertRulesetComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptSetupActionAssertRulesetComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptSetupActionAssertRulesetComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.SetupActionAssertRulesetComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rulesetId")) {
- res.setRulesetIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("rule")) {
- res.getRule().add(parseTestScriptSetupActionAssertRulesetRuleComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.SetupActionAssertRulesetRuleComponent parseTestScriptSetupActionAssertRulesetRuleComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.SetupActionAssertRulesetRuleComponent res = new TestScript.SetupActionAssertRulesetRuleComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptSetupActionAssertRulesetRuleComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptSetupActionAssertRulesetRuleComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.SetupActionAssertRulesetRuleComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("ruleId")) {
- res.setRuleIdElement(parseId(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("param")) {
- res.getParam().add(parseTestScriptSetupActionAssertRulesetRuleParamComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.SetupActionAssertRulesetRuleParamComponent parseTestScriptSetupActionAssertRulesetRuleParamComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.SetupActionAssertRulesetRuleParamComponent res = new TestScript.SetupActionAssertRulesetRuleParamComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptSetupActionAssertRulesetRuleParamComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptSetupActionAssertRulesetRuleParamComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.SetupActionAssertRulesetRuleParamComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptTestComponent parseTestScriptTestScriptTestComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptTestComponent res = new TestScript.TestScriptTestComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptTestComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptTestComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptTestComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("metadata")) {
- res.setMetadata(parseTestScriptTestScriptMetadataComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseTestScriptTestActionComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestActionComponent parseTestScriptTestActionComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestActionComponent res = new TestScript.TestActionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestActionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestActionComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestActionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("operation")) {
- res.setOperation(parseTestScriptSetupActionOperationComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("assert")) {
- res.setAssert(parseTestScriptSetupActionAssertComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TestScriptTeardownComponent parseTestScriptTestScriptTeardownComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TestScriptTeardownComponent res = new TestScript.TestScriptTeardownComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTestScriptTeardownComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTestScriptTeardownComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TestScriptTeardownComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("action")) {
- res.getAction().add(parseTestScriptTeardownActionComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected TestScript.TeardownActionComponent parseTestScriptTeardownActionComponent(XmlPullParser xpp, TestScript owner) throws XmlPullParserException, IOException, FHIRFormatError {
- TestScript.TeardownActionComponent res = new TestScript.TeardownActionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseTestScriptTeardownActionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseTestScriptTeardownActionComponentContent(int eventType, XmlPullParser xpp, TestScript owner, TestScript.TeardownActionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("operation")) {
- res.setOperation(parseTestScriptSetupActionOperationComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ValueSet parseValueSet(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- ValueSet res = new ValueSet();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseValueSetContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseValueSetContent(int eventType, XmlPullParser xpp, ValueSet res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("url")) {
- res.setUrlElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifier(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("status")) {
- res.setStatusElement(parseEnumeration(xpp, Enumerations.ConformanceResourceStatus.NULL, new Enumerations.ConformanceResourceStatusEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("experimental")) {
- res.setExperimentalElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("publisher")) {
- res.setPublisherElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contact")) {
- res.getContact().add(parseValueSetValueSetContactComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("date")) {
- res.setDateElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("lockedDate")) {
- res.setLockedDateElement(parseDate(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("description")) {
- res.setDescriptionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("useContext")) {
- res.getUseContext().add(parseCodeableConcept(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("immutable")) {
- res.setImmutableElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("requirements")) {
- res.setRequirementsElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("copyright")) {
- res.setCopyrightElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("extensible")) {
- res.setExtensibleElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("compose")) {
- res.setCompose(parseValueSetValueSetComposeComponent(xpp, res));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("expansion")) {
- res.setExpansion(parseValueSetValueSetExpansionComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ValueSet.ValueSetContactComponent parseValueSetValueSetContactComponent(XmlPullParser xpp, ValueSet owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ValueSet.ValueSetContactComponent res = new ValueSet.ValueSetContactComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseValueSetValueSetContactComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseValueSetValueSetContactComponentContent(int eventType, XmlPullParser xpp, ValueSet owner, ValueSet.ValueSetContactComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("telecom")) {
- res.getTelecom().add(parseContactPoint(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ValueSet.ValueSetComposeComponent parseValueSetValueSetComposeComponent(XmlPullParser xpp, ValueSet owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ValueSet.ValueSetComposeComponent res = new ValueSet.ValueSetComposeComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseValueSetValueSetComposeComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseValueSetValueSetComposeComponentContent(int eventType, XmlPullParser xpp, ValueSet owner, ValueSet.ValueSetComposeComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("import")) {
- res.getImport().add(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("include")) {
- res.getInclude().add(parseValueSetConceptSetComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("exclude")) {
- res.getExclude().add(parseValueSetConceptSetComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ValueSet.ConceptSetComponent parseValueSetConceptSetComponent(XmlPullParser xpp, ValueSet owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ValueSet.ConceptSetComponent res = new ValueSet.ConceptSetComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseValueSetConceptSetComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseValueSetConceptSetComponentContent(int eventType, XmlPullParser xpp, ValueSet owner, ValueSet.ConceptSetComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("concept")) {
- res.getConcept().add(parseValueSetConceptReferenceComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("filter")) {
- res.getFilter().add(parseValueSetConceptSetFilterComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ValueSet.ConceptReferenceComponent parseValueSetConceptReferenceComponent(XmlPullParser xpp, ValueSet owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ValueSet.ConceptReferenceComponent res = new ValueSet.ConceptReferenceComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseValueSetConceptReferenceComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseValueSetConceptReferenceComponentContent(int eventType, XmlPullParser xpp, ValueSet owner, ValueSet.ConceptReferenceComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("display")) {
- res.setDisplayElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("designation")) {
- res.getDesignation().add(parseValueSetConceptReferenceDesignationComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ValueSet.ConceptReferenceDesignationComponent parseValueSetConceptReferenceDesignationComponent(XmlPullParser xpp, ValueSet owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ValueSet.ConceptReferenceDesignationComponent res = new ValueSet.ConceptReferenceDesignationComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseValueSetConceptReferenceDesignationComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseValueSetConceptReferenceDesignationComponentContent(int eventType, XmlPullParser xpp, ValueSet owner, ValueSet.ConceptReferenceDesignationComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("language")) {
- res.setLanguageElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("use")) {
- res.setUse(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ValueSet.ConceptSetFilterComponent parseValueSetConceptSetFilterComponent(XmlPullParser xpp, ValueSet owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ValueSet.ConceptSetFilterComponent res = new ValueSet.ConceptSetFilterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseValueSetConceptSetFilterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseValueSetConceptSetFilterComponentContent(int eventType, XmlPullParser xpp, ValueSet owner, ValueSet.ConceptSetFilterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("property")) {
- res.setPropertyElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("op")) {
- res.setOpElement(parseEnumeration(xpp, ValueSet.FilterOperator.NULL, new ValueSet.FilterOperatorEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("value")) {
- res.setValueElement(parseCode(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ValueSet.ValueSetExpansionComponent parseValueSetValueSetExpansionComponent(XmlPullParser xpp, ValueSet owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ValueSet.ValueSetExpansionComponent res = new ValueSet.ValueSetExpansionComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseValueSetValueSetExpansionComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseValueSetValueSetExpansionComponentContent(int eventType, XmlPullParser xpp, ValueSet owner, ValueSet.ValueSetExpansionComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.setIdentifierElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("timestamp")) {
- res.setTimestampElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("total")) {
- res.setTotalElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("offset")) {
- res.setOffsetElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("parameter")) {
- res.getParameter().add(parseValueSetValueSetExpansionParameterComponent(xpp, owner));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contains")) {
- res.getContains().add(parseValueSetValueSetExpansionContainsComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ValueSet.ValueSetExpansionParameterComponent parseValueSetValueSetExpansionParameterComponent(XmlPullParser xpp, ValueSet owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ValueSet.ValueSetExpansionParameterComponent res = new ValueSet.ValueSetExpansionParameterComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseValueSetValueSetExpansionParameterComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseValueSetValueSetExpansionParameterComponentContent(int eventType, XmlPullParser xpp, ValueSet owner, ValueSet.ValueSetExpansionParameterComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("name")) {
- res.setNameElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "value")) {
- res.setValue(parseType("value", xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected ValueSet.ValueSetExpansionContainsComponent parseValueSetValueSetExpansionContainsComponent(XmlPullParser xpp, ValueSet owner) throws XmlPullParserException, IOException, FHIRFormatError {
- ValueSet.ValueSetExpansionContainsComponent res = new ValueSet.ValueSetExpansionContainsComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseValueSetValueSetExpansionContainsComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseValueSetValueSetExpansionContainsComponentContent(int eventType, XmlPullParser xpp, ValueSet owner, ValueSet.ValueSetExpansionContainsComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("system")) {
- res.setSystemElement(parseUri(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("abstract")) {
- res.setAbstractElement(parseBoolean(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("version")) {
- res.setVersionElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("code")) {
- res.setCodeElement(parseCode(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("display")) {
- res.setDisplayElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("contains")) {
- res.getContains().add(parseValueSetValueSetExpansionContainsComponent(xpp, owner));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected VisionPrescription parseVisionPrescription(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- VisionPrescription res = new VisionPrescription();
- parseDomainResourceAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseVisionPrescriptionContent(eventType, xpp, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseVisionPrescriptionContent(int eventType, XmlPullParser xpp, VisionPrescription res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("identifier")) {
- res.getIdentifier().add(parseIdentifier(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dateWritten")) {
- res.setDateWrittenElement(parseDateTime(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("patient")) {
- res.setPatient(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prescriber")) {
- res.setPrescriber(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("encounter")) {
- res.setEncounter(parseReference(xpp));
- } else if (eventType == XmlPullParser.START_TAG && nameIsTypeName(xpp, "reason")) {
- res.setReason(parseType("reason", xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("dispense")) {
- res.getDispense().add(parseVisionPrescriptionVisionPrescriptionDispenseComponent(xpp, res));
- } else if (!parseDomainResourceContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- protected VisionPrescription.VisionPrescriptionDispenseComponent parseVisionPrescriptionVisionPrescriptionDispenseComponent(XmlPullParser xpp, VisionPrescription owner) throws XmlPullParserException, IOException, FHIRFormatError {
- VisionPrescription.VisionPrescriptionDispenseComponent res = new VisionPrescription.VisionPrescriptionDispenseComponent();
- parseBackboneAttributes(xpp, res);
- next(xpp);
- int eventType = nextNoWhitespace(xpp);
- while (eventType != XmlPullParser.END_TAG) {
- if (!parseVisionPrescriptionVisionPrescriptionDispenseComponentContent(eventType, xpp, owner, res))
- unknownContent(xpp);
- eventType = nextNoWhitespace(xpp);
- }
- next(xpp);
- parseElementClose(res);
- return res;
- }
-
- protected boolean parseVisionPrescriptionVisionPrescriptionDispenseComponentContent(int eventType, XmlPullParser xpp, VisionPrescription owner, VisionPrescription.VisionPrescriptionDispenseComponent res) throws XmlPullParserException, IOException, FHIRFormatError {
- if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("product")) {
- res.setProduct(parseCoding(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("eye")) {
- res.setEyeElement(parseEnumeration(xpp, VisionPrescription.VisionEyes.NULL, new VisionPrescription.VisionEyesEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("sphere")) {
- res.setSphereElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("cylinder")) {
- res.setCylinderElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("axis")) {
- res.setAxisElement(parseInteger(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("prism")) {
- res.setPrismElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("base")) {
- res.setBaseElement(parseEnumeration(xpp, VisionPrescription.VisionBase.NULL, new VisionPrescription.VisionBaseEnumFactory()));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("add")) {
- res.setAddElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("power")) {
- res.setPowerElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("backCurve")) {
- res.setBackCurveElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("diameter")) {
- res.setDiameterElement(parseDecimal(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("duration")) {
- res.setDuration(parseSimpleQuantity(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("color")) {
- res.setColorElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("brand")) {
- res.setBrandElement(parseString(xpp));
- } else if (eventType == XmlPullParser.START_TAG && xpp.getName().equals("notes")) {
- res.setNotesElement(parseString(xpp));
- } else if (!parseBackboneContent(eventType, xpp, res))
- return false;
- return true;
- }
-
- @Override
- protected Resource parseResource(XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- if (xpp.getName().equals("Parameters"))
- return parseParameters(xpp);
- else if (xpp.getName().equals("Account"))
- return parseAccount(xpp);
- else if (xpp.getName().equals("AllergyIntolerance"))
- return parseAllergyIntolerance(xpp);
- else if (xpp.getName().equals("Appointment"))
- return parseAppointment(xpp);
- else if (xpp.getName().equals("AppointmentResponse"))
- return parseAppointmentResponse(xpp);
- else if (xpp.getName().equals("AuditEvent"))
- return parseAuditEvent(xpp);
- else if (xpp.getName().equals("Basic"))
- return parseBasic(xpp);
- else if (xpp.getName().equals("Binary"))
- return parseBinary(xpp);
- else if (xpp.getName().equals("BodySite"))
- return parseBodySite(xpp);
- else if (xpp.getName().equals("Bundle"))
- return parseBundle(xpp);
- else if (xpp.getName().equals("CarePlan"))
- return parseCarePlan(xpp);
- else if (xpp.getName().equals("CareTeam"))
- return parseCareTeam(xpp);
- else if (xpp.getName().equals("Claim"))
- return parseClaim(xpp);
- else if (xpp.getName().equals("ClaimResponse"))
- return parseClaimResponse(xpp);
- else if (xpp.getName().equals("ClinicalImpression"))
- return parseClinicalImpression(xpp);
- else if (xpp.getName().equals("CodeSystem"))
- return parseCodeSystem(xpp);
- else if (xpp.getName().equals("Communication"))
- return parseCommunication(xpp);
- else if (xpp.getName().equals("CommunicationRequest"))
- return parseCommunicationRequest(xpp);
- else if (xpp.getName().equals("CompartmentDefinition"))
- return parseCompartmentDefinition(xpp);
- else if (xpp.getName().equals("Composition"))
- return parseComposition(xpp);
- else if (xpp.getName().equals("ConceptMap"))
- return parseConceptMap(xpp);
- else if (xpp.getName().equals("Condition"))
- return parseCondition(xpp);
- else if (xpp.getName().equals("Conformance"))
- return parseConformance(xpp);
- else if (xpp.getName().equals("Consent"))
- return parseConsent(xpp);
- else if (xpp.getName().equals("Contract"))
- return parseContract(xpp);
- else if (xpp.getName().equals("Coverage"))
- return parseCoverage(xpp);
- else if (xpp.getName().equals("DataElement"))
- return parseDataElement(xpp);
- else if (xpp.getName().equals("DecisionSupportRule"))
- return parseDecisionSupportRule(xpp);
- else if (xpp.getName().equals("DecisionSupportServiceModule"))
- return parseDecisionSupportServiceModule(xpp);
- else if (xpp.getName().equals("DetectedIssue"))
- return parseDetectedIssue(xpp);
- else if (xpp.getName().equals("Device"))
- return parseDevice(xpp);
- else if (xpp.getName().equals("DeviceComponent"))
- return parseDeviceComponent(xpp);
- else if (xpp.getName().equals("DeviceMetric"))
- return parseDeviceMetric(xpp);
- else if (xpp.getName().equals("DeviceUseRequest"))
- return parseDeviceUseRequest(xpp);
- else if (xpp.getName().equals("DeviceUseStatement"))
- return parseDeviceUseStatement(xpp);
- else if (xpp.getName().equals("DiagnosticOrder"))
- return parseDiagnosticOrder(xpp);
- else if (xpp.getName().equals("DiagnosticReport"))
- return parseDiagnosticReport(xpp);
- else if (xpp.getName().equals("DocumentManifest"))
- return parseDocumentManifest(xpp);
- else if (xpp.getName().equals("DocumentReference"))
- return parseDocumentReference(xpp);
- else if (xpp.getName().equals("EligibilityRequest"))
- return parseEligibilityRequest(xpp);
- else if (xpp.getName().equals("EligibilityResponse"))
- return parseEligibilityResponse(xpp);
- else if (xpp.getName().equals("Encounter"))
- return parseEncounter(xpp);
- else if (xpp.getName().equals("Endpoint"))
- return parseEndpoint(xpp);
- else if (xpp.getName().equals("EnrollmentRequest"))
- return parseEnrollmentRequest(xpp);
- else if (xpp.getName().equals("EnrollmentResponse"))
- return parseEnrollmentResponse(xpp);
- else if (xpp.getName().equals("EpisodeOfCare"))
- return parseEpisodeOfCare(xpp);
- else if (xpp.getName().equals("ExpansionProfile"))
- return parseExpansionProfile(xpp);
- else if (xpp.getName().equals("ExplanationOfBenefit"))
- return parseExplanationOfBenefit(xpp);
- else if (xpp.getName().equals("FamilyMemberHistory"))
- return parseFamilyMemberHistory(xpp);
- else if (xpp.getName().equals("Flag"))
- return parseFlag(xpp);
- else if (xpp.getName().equals("Goal"))
- return parseGoal(xpp);
- else if (xpp.getName().equals("Group"))
- return parseGroup(xpp);
- else if (xpp.getName().equals("GuidanceResponse"))
- return parseGuidanceResponse(xpp);
- else if (xpp.getName().equals("HealthcareService"))
- return parseHealthcareService(xpp);
- else if (xpp.getName().equals("ImagingStudy"))
- return parseImagingStudy(xpp);
- else if (xpp.getName().equals("Immunization"))
- return parseImmunization(xpp);
- else if (xpp.getName().equals("ImmunizationRecommendation"))
- return parseImmunizationRecommendation(xpp);
- else if (xpp.getName().equals("ImplementationGuide"))
- return parseImplementationGuide(xpp);
- else if (xpp.getName().equals("Library"))
- return parseLibrary(xpp);
- else if (xpp.getName().equals("Linkage"))
- return parseLinkage(xpp);
- else if (xpp.getName().equals("List"))
- return parseListResource(xpp);
- else if (xpp.getName().equals("Location"))
- return parseLocation(xpp);
- else if (xpp.getName().equals("Measure"))
- return parseMeasure(xpp);
- else if (xpp.getName().equals("MeasureReport"))
- return parseMeasureReport(xpp);
- else if (xpp.getName().equals("Media"))
- return parseMedia(xpp);
- else if (xpp.getName().equals("Medication"))
- return parseMedication(xpp);
- else if (xpp.getName().equals("MedicationAdministration"))
- return parseMedicationAdministration(xpp);
- else if (xpp.getName().equals("MedicationDispense"))
- return parseMedicationDispense(xpp);
- else if (xpp.getName().equals("MedicationOrder"))
- return parseMedicationOrder(xpp);
- else if (xpp.getName().equals("MedicationStatement"))
- return parseMedicationStatement(xpp);
- else if (xpp.getName().equals("MessageHeader"))
- return parseMessageHeader(xpp);
- else if (xpp.getName().equals("ModuleDefinition"))
- return parseModuleDefinition(xpp);
- else if (xpp.getName().equals("NamingSystem"))
- return parseNamingSystem(xpp);
- else if (xpp.getName().equals("NutritionOrder"))
- return parseNutritionOrder(xpp);
- else if (xpp.getName().equals("Observation"))
- return parseObservation(xpp);
- else if (xpp.getName().equals("OperationDefinition"))
- return parseOperationDefinition(xpp);
- else if (xpp.getName().equals("OperationOutcome"))
- return parseOperationOutcome(xpp);
- else if (xpp.getName().equals("Order"))
- return parseOrder(xpp);
- else if (xpp.getName().equals("OrderResponse"))
- return parseOrderResponse(xpp);
- else if (xpp.getName().equals("OrderSet"))
- return parseOrderSet(xpp);
- else if (xpp.getName().equals("Organization"))
- return parseOrganization(xpp);
- else if (xpp.getName().equals("Patient"))
- return parsePatient(xpp);
- else if (xpp.getName().equals("PaymentNotice"))
- return parsePaymentNotice(xpp);
- else if (xpp.getName().equals("PaymentReconciliation"))
- return parsePaymentReconciliation(xpp);
- else if (xpp.getName().equals("Person"))
- return parsePerson(xpp);
- else if (xpp.getName().equals("Practitioner"))
- return parsePractitioner(xpp);
- else if (xpp.getName().equals("PractitionerRole"))
- return parsePractitionerRole(xpp);
- else if (xpp.getName().equals("Procedure"))
- return parseProcedure(xpp);
- else if (xpp.getName().equals("ProcedureRequest"))
- return parseProcedureRequest(xpp);
- else if (xpp.getName().equals("ProcessRequest"))
- return parseProcessRequest(xpp);
- else if (xpp.getName().equals("ProcessResponse"))
- return parseProcessResponse(xpp);
- else if (xpp.getName().equals("Protocol"))
- return parseProtocol(xpp);
- else if (xpp.getName().equals("Provenance"))
- return parseProvenance(xpp);
- else if (xpp.getName().equals("Questionnaire"))
- return parseQuestionnaire(xpp);
- else if (xpp.getName().equals("QuestionnaireResponse"))
- return parseQuestionnaireResponse(xpp);
- else if (xpp.getName().equals("ReferralRequest"))
- return parseReferralRequest(xpp);
- else if (xpp.getName().equals("RelatedPerson"))
- return parseRelatedPerson(xpp);
- else if (xpp.getName().equals("RiskAssessment"))
- return parseRiskAssessment(xpp);
- else if (xpp.getName().equals("Schedule"))
- return parseSchedule(xpp);
- else if (xpp.getName().equals("SearchParameter"))
- return parseSearchParameter(xpp);
- else if (xpp.getName().equals("Sequence"))
- return parseSequence(xpp);
- else if (xpp.getName().equals("Slot"))
- return parseSlot(xpp);
- else if (xpp.getName().equals("Specimen"))
- return parseSpecimen(xpp);
- else if (xpp.getName().equals("StructureDefinition"))
- return parseStructureDefinition(xpp);
- else if (xpp.getName().equals("StructureMap"))
- return parseStructureMap(xpp);
- else if (xpp.getName().equals("Subscription"))
- return parseSubscription(xpp);
- else if (xpp.getName().equals("Substance"))
- return parseSubstance(xpp);
- else if (xpp.getName().equals("SupplyDelivery"))
- return parseSupplyDelivery(xpp);
- else if (xpp.getName().equals("SupplyRequest"))
- return parseSupplyRequest(xpp);
- else if (xpp.getName().equals("Task"))
- return parseTask(xpp);
- else if (xpp.getName().equals("TestScript"))
- return parseTestScript(xpp);
- else if (xpp.getName().equals("ValueSet"))
- return parseValueSet(xpp);
- else if (xpp.getName().equals("VisionPrescription"))
- return parseVisionPrescription(xpp);
- else if (xpp.getName().equals("Binary"))
- return parseBinary(xpp);
- throw new FHIRFormatError("Unknown resource type "+xpp.getName()+"");
- }
-
- protected Type parseType(String prefix, XmlPullParser xpp) throws XmlPullParserException, IOException, FHIRFormatError {
- if (xpp.getName().equals(prefix+"date"))
- return parseDate(xpp);
- else if (xpp.getName().equals(prefix+"dateTime"))
- return parseDateTime(xpp);
- else if (xpp.getName().equals(prefix+"code"))
- return parseCode(xpp);
- else if (xpp.getName().equals(prefix+"string"))
- return parseString(xpp);
- else if (xpp.getName().equals(prefix+"integer"))
- return parseInteger(xpp);
- else if (xpp.getName().equals(prefix+"oid"))
- return parseOid(xpp);
- else if (xpp.getName().equals(prefix+"uri"))
- return parseUri(xpp);
- else if (xpp.getName().equals(prefix+"uuid"))
- return parseUuid(xpp);
- else if (xpp.getName().equals(prefix+"instant"))
- return parseInstant(xpp);
- else if (xpp.getName().equals(prefix+"boolean"))
- return parseBoolean(xpp);
- else if (xpp.getName().equals(prefix+"base64Binary"))
- return parseBase64Binary(xpp);
- else if (xpp.getName().equals(prefix+"unsignedInt"))
- return parseUnsignedInt(xpp);
- else if (xpp.getName().equals(prefix+"markdown"))
- return parseMarkdown(xpp);
- else if (xpp.getName().equals(prefix+"time"))
- return parseTime(xpp);
- else if (xpp.getName().equals(prefix+"id"))
- return parseId(xpp);
- else if (xpp.getName().equals(prefix+"positiveInt"))
- return parsePositiveInt(xpp);
- else if (xpp.getName().equals(prefix+"decimal"))
- return parseDecimal(xpp);
- else if (xpp.getName().equals(prefix+"Extension"))
- return parseExtension(xpp);
- else if (xpp.getName().equals(prefix+"Narrative"))
- return parseNarrative(xpp);
- else if (xpp.getName().equals(prefix+"Reference"))
- return parseReference(xpp);
- else if (xpp.getName().equals(prefix+"Quantity"))
- return parseQuantity(xpp);
- else if (xpp.getName().equals(prefix+"Period"))
- return parsePeriod(xpp);
- else if (xpp.getName().equals(prefix+"Attachment"))
- return parseAttachment(xpp);
- else if (xpp.getName().equals(prefix+"Duration"))
- return parseDuration(xpp);
- else if (xpp.getName().equals(prefix+"Count"))
- return parseCount(xpp);
- else if (xpp.getName().equals(prefix+"Range"))
- return parseRange(xpp);
- else if (xpp.getName().equals(prefix+"Annotation"))
- return parseAnnotation(xpp);
- else if (xpp.getName().equals(prefix+"Money"))
- return parseMoney(xpp);
- else if (xpp.getName().equals(prefix+"Identifier"))
- return parseIdentifier(xpp);
- else if (xpp.getName().equals(prefix+"Coding"))
- return parseCoding(xpp);
- else if (xpp.getName().equals(prefix+"Signature"))
- return parseSignature(xpp);
- else if (xpp.getName().equals(prefix+"SampledData"))
- return parseSampledData(xpp);
- else if (xpp.getName().equals(prefix+"Ratio"))
- return parseRatio(xpp);
- else if (xpp.getName().equals(prefix+"Distance"))
- return parseDistance(xpp);
- else if (xpp.getName().equals(prefix+"Age"))
- return parseAge(xpp);
- else if (xpp.getName().equals(prefix+"CodeableConcept"))
- return parseCodeableConcept(xpp);
- else if (xpp.getName().equals(prefix+"SimpleQuantity"))
- return parseSimpleQuantity(xpp);
- else if (xpp.getName().equals(prefix+"HumanName"))
- return parseHumanName(xpp);
- else if (xpp.getName().equals(prefix+"ContactPoint"))
- return parseContactPoint(xpp);
- else if (xpp.getName().equals(prefix+"Meta"))
- return parseMeta(xpp);
- else if (xpp.getName().equals(prefix+"Address"))
- return parseAddress(xpp);
- else if (xpp.getName().equals(prefix+"TriggerDefinition"))
- return parseTriggerDefinition(xpp);
- else if (xpp.getName().equals(prefix+"ModuleMetadata"))
- return parseModuleMetadata(xpp);
- else if (xpp.getName().equals(prefix+"Timing"))
- return parseTiming(xpp);
- else if (xpp.getName().equals(prefix+"ElementDefinition"))
- return parseElementDefinition(xpp);
- else if (xpp.getName().equals(prefix+"DataRequirement"))
- return parseDataRequirement(xpp);
- else if (xpp.getName().equals(prefix+"ActionDefinition"))
- return parseActionDefinition(xpp);
- else if (xpp.getName().equals(prefix+"ParameterDefinition"))
- return parseParameterDefinition(xpp);
- else if (xpp.getName().equals(prefix+"Date"))
- return parseDate(xpp);
- else if (xpp.getName().equals(prefix+"DateTime"))
- return parseDateTime(xpp);
- else if (xpp.getName().equals(prefix+"Code"))
- return parseCode(xpp);
- else if (xpp.getName().equals(prefix+"String"))
- return parseString(xpp);
- else if (xpp.getName().equals(prefix+"Integer"))
- return parseInteger(xpp);
- else if (xpp.getName().equals(prefix+"Oid"))
- return parseOid(xpp);
- else if (xpp.getName().equals(prefix+"Uri"))
- return parseUri(xpp);
- else if (xpp.getName().equals(prefix+"Uuid"))
- return parseUuid(xpp);
- else if (xpp.getName().equals(prefix+"Instant"))
- return parseInstant(xpp);
- else if (xpp.getName().equals(prefix+"Boolean"))
- return parseBoolean(xpp);
- else if (xpp.getName().equals(prefix+"Base64Binary"))
- return parseBase64Binary(xpp);
- else if (xpp.getName().equals(prefix+"UnsignedInt"))
- return parseUnsignedInt(xpp);
- else if (xpp.getName().equals(prefix+"Markdown"))
- return parseMarkdown(xpp);
- else if (xpp.getName().equals(prefix+"Time"))
- return parseTime(xpp);
- else if (xpp.getName().equals(prefix+"Id"))
- return parseId(xpp);
- else if (xpp.getName().equals(prefix+"PositiveInt"))
- return parsePositiveInt(xpp);
- else if (xpp.getName().equals(prefix+"Decimal"))
- return parseDecimal(xpp);
- throw new FHIRFormatError("Unknown type "+xpp.getName());
- }
-
- protected Type parseType(XmlPullParser xpp, String type) throws XmlPullParserException, IOException, FHIRFormatError {
- if (type.equals("date"))
- return parseDate(xpp);
- else if (type.equals("dateTime"))
- return parseDateTime(xpp);
- else if (type.equals("code"))
- return parseCode(xpp);
- else if (type.equals("string"))
- return parseString(xpp);
- else if (type.equals("integer"))
- return parseInteger(xpp);
- else if (type.equals("oid"))
- return parseOid(xpp);
- else if (type.equals("uri"))
- return parseUri(xpp);
- else if (type.equals("uuid"))
- return parseUuid(xpp);
- else if (type.equals("instant"))
- return parseInstant(xpp);
- else if (type.equals("boolean"))
- return parseBoolean(xpp);
- else if (type.equals("base64Binary"))
- return parseBase64Binary(xpp);
- else if (type.equals("unsignedInt"))
- return parseUnsignedInt(xpp);
- else if (type.equals("markdown"))
- return parseMarkdown(xpp);
- else if (type.equals("time"))
- return parseTime(xpp);
- else if (type.equals("id"))
- return parseId(xpp);
- else if (type.equals("positiveInt"))
- return parsePositiveInt(xpp);
- else if (type.equals("decimal"))
- return parseDecimal(xpp);
- else if (type.equals("Extension"))
- return parseExtension(xpp);
- else if (type.equals("Narrative"))
- return parseNarrative(xpp);
- else if (type.equals("Reference"))
- return parseReference(xpp);
- else if (type.equals("Quantity"))
- return parseQuantity(xpp);
- else if (type.equals("Period"))
- return parsePeriod(xpp);
- else if (type.equals("Attachment"))
- return parseAttachment(xpp);
- else if (type.equals("Duration"))
- return parseDuration(xpp);
- else if (type.equals("Count"))
- return parseCount(xpp);
- else if (type.equals("Range"))
- return parseRange(xpp);
- else if (type.equals("Annotation"))
- return parseAnnotation(xpp);
- else if (type.equals("Money"))
- return parseMoney(xpp);
- else if (type.equals("Identifier"))
- return parseIdentifier(xpp);
- else if (type.equals("Coding"))
- return parseCoding(xpp);
- else if (type.equals("Signature"))
- return parseSignature(xpp);
- else if (type.equals("SampledData"))
- return parseSampledData(xpp);
- else if (type.equals("Ratio"))
- return parseRatio(xpp);
- else if (type.equals("Distance"))
- return parseDistance(xpp);
- else if (type.equals("Age"))
- return parseAge(xpp);
- else if (type.equals("CodeableConcept"))
- return parseCodeableConcept(xpp);
- else if (type.equals("SimpleQuantity"))
- return parseSimpleQuantity(xpp);
- else if (type.equals("HumanName"))
- return parseHumanName(xpp);
- else if (type.equals("ContactPoint"))
- return parseContactPoint(xpp);
- else if (type.equals("Meta"))
- return parseMeta(xpp);
- else if (type.equals("Address"))
- return parseAddress(xpp);
- else if (type.equals("TriggerDefinition"))
- return parseTriggerDefinition(xpp);
- else if (type.equals("ModuleMetadata"))
- return parseModuleMetadata(xpp);
- else if (type.equals("Timing"))
- return parseTiming(xpp);
- else if (type.equals("ElementDefinition"))
- return parseElementDefinition(xpp);
- else if (type.equals("DataRequirement"))
- return parseDataRequirement(xpp);
- else if (type.equals("ActionDefinition"))
- return parseActionDefinition(xpp);
- else if (type.equals("ParameterDefinition"))
- return parseParameterDefinition(xpp);
- throw new FHIRFormatError("Unknown type "+type);
- }
-
- public Base parseFragment(XmlPullParser xpp, String type) throws XmlPullParserException, IOException, FHIRFormatError {
- if (type.equals("Extension"))
- return parseExtension(xpp);
- else if (type.equals("Narrative"))
- return parseNarrative(xpp);
- else if (type.equals("Reference"))
- return parseReference(xpp);
- else if (type.equals("Quantity"))
- return parseQuantity(xpp);
- else if (type.equals("Period"))
- return parsePeriod(xpp);
- else if (type.equals("Attachment"))
- return parseAttachment(xpp);
- else if (type.equals("Duration"))
- return parseDuration(xpp);
- else if (type.equals("Count"))
- return parseCount(xpp);
- else if (type.equals("Range"))
- return parseRange(xpp);
- else if (type.equals("Annotation"))
- return parseAnnotation(xpp);
- else if (type.equals("Money"))
- return parseMoney(xpp);
- else if (type.equals("Identifier"))
- return parseIdentifier(xpp);
- else if (type.equals("Coding"))
- return parseCoding(xpp);
- else if (type.equals("Signature"))
- return parseSignature(xpp);
- else if (type.equals("SampledData"))
- return parseSampledData(xpp);
- else if (type.equals("Ratio"))
- return parseRatio(xpp);
- else if (type.equals("Distance"))
- return parseDistance(xpp);
- else if (type.equals("Age"))
- return parseAge(xpp);
- else if (type.equals("CodeableConcept"))
- return parseCodeableConcept(xpp);
- else if (type.equals("SimpleQuantity"))
- return parseSimpleQuantity(xpp);
- else if (type.equals("HumanName"))
- return parseHumanName(xpp);
- else if (type.equals("ContactPoint"))
- return parseContactPoint(xpp);
- else if (type.equals("Meta"))
- return parseMeta(xpp);
- else if (type.equals("Address"))
- return parseAddress(xpp);
- else if (type.equals("TriggerDefinition"))
- return parseTriggerDefinition(xpp);
- else if (type.equals("ModuleMetadata"))
- return parseModuleMetadata(xpp);
- else if (type.equals("Timing"))
- return parseTiming(xpp);
- else if (type.equals("ElementDefinition"))
- return parseElementDefinition(xpp);
- else if (type.equals("DataRequirement"))
- return parseDataRequirement(xpp);
- else if (type.equals("ActionDefinition"))
- return parseActionDefinition(xpp);
- else if (type.equals("ParameterDefinition"))
- return parseParameterDefinition(xpp);
- else if (type.equals("Parameters"))
- return parseParameters(xpp);
- else if (type.equals("Account"))
- return parseAccount(xpp);
- else if (type.equals("AllergyIntolerance"))
- return parseAllergyIntolerance(xpp);
- else if (type.equals("Appointment"))
- return parseAppointment(xpp);
- else if (type.equals("AppointmentResponse"))
- return parseAppointmentResponse(xpp);
- else if (type.equals("AuditEvent"))
- return parseAuditEvent(xpp);
- else if (type.equals("Basic"))
- return parseBasic(xpp);
- else if (type.equals("Binary"))
- return parseBinary(xpp);
- else if (type.equals("BodySite"))
- return parseBodySite(xpp);
- else if (type.equals("Bundle"))
- return parseBundle(xpp);
- else if (type.equals("CarePlan"))
- return parseCarePlan(xpp);
- else if (type.equals("CareTeam"))
- return parseCareTeam(xpp);
- else if (type.equals("Claim"))
- return parseClaim(xpp);
- else if (type.equals("ClaimResponse"))
- return parseClaimResponse(xpp);
- else if (type.equals("ClinicalImpression"))
- return parseClinicalImpression(xpp);
- else if (type.equals("CodeSystem"))
- return parseCodeSystem(xpp);
- else if (type.equals("Communication"))
- return parseCommunication(xpp);
- else if (type.equals("CommunicationRequest"))
- return parseCommunicationRequest(xpp);
- else if (type.equals("CompartmentDefinition"))
- return parseCompartmentDefinition(xpp);
- else if (type.equals("Composition"))
- return parseComposition(xpp);
- else if (type.equals("ConceptMap"))
- return parseConceptMap(xpp);
- else if (type.equals("Condition"))
- return parseCondition(xpp);
- else if (type.equals("Conformance"))
- return parseConformance(xpp);
- else if (type.equals("Consent"))
- return parseConsent(xpp);
- else if (type.equals("Contract"))
- return parseContract(xpp);
- else if (type.equals("Coverage"))
- return parseCoverage(xpp);
- else if (type.equals("DataElement"))
- return parseDataElement(xpp);
- else if (type.equals("DecisionSupportRule"))
- return parseDecisionSupportRule(xpp);
- else if (type.equals("DecisionSupportServiceModule"))
- return parseDecisionSupportServiceModule(xpp);
- else if (type.equals("DetectedIssue"))
- return parseDetectedIssue(xpp);
- else if (type.equals("Device"))
- return parseDevice(xpp);
- else if (type.equals("DeviceComponent"))
- return parseDeviceComponent(xpp);
- else if (type.equals("DeviceMetric"))
- return parseDeviceMetric(xpp);
- else if (type.equals("DeviceUseRequest"))
- return parseDeviceUseRequest(xpp);
- else if (type.equals("DeviceUseStatement"))
- return parseDeviceUseStatement(xpp);
- else if (type.equals("DiagnosticOrder"))
- return parseDiagnosticOrder(xpp);
- else if (type.equals("DiagnosticReport"))
- return parseDiagnosticReport(xpp);
- else if (type.equals("DocumentManifest"))
- return parseDocumentManifest(xpp);
- else if (type.equals("DocumentReference"))
- return parseDocumentReference(xpp);
- else if (type.equals("EligibilityRequest"))
- return parseEligibilityRequest(xpp);
- else if (type.equals("EligibilityResponse"))
- return parseEligibilityResponse(xpp);
- else if (type.equals("Encounter"))
- return parseEncounter(xpp);
- else if (type.equals("Endpoint"))
- return parseEndpoint(xpp);
- else if (type.equals("EnrollmentRequest"))
- return parseEnrollmentRequest(xpp);
- else if (type.equals("EnrollmentResponse"))
- return parseEnrollmentResponse(xpp);
- else if (type.equals("EpisodeOfCare"))
- return parseEpisodeOfCare(xpp);
- else if (type.equals("ExpansionProfile"))
- return parseExpansionProfile(xpp);
- else if (type.equals("ExplanationOfBenefit"))
- return parseExplanationOfBenefit(xpp);
- else if (type.equals("FamilyMemberHistory"))
- return parseFamilyMemberHistory(xpp);
- else if (type.equals("Flag"))
- return parseFlag(xpp);
- else if (type.equals("Goal"))
- return parseGoal(xpp);
- else if (type.equals("Group"))
- return parseGroup(xpp);
- else if (type.equals("GuidanceResponse"))
- return parseGuidanceResponse(xpp);
- else if (type.equals("HealthcareService"))
- return parseHealthcareService(xpp);
- else if (type.equals("ImagingStudy"))
- return parseImagingStudy(xpp);
- else if (type.equals("Immunization"))
- return parseImmunization(xpp);
- else if (type.equals("ImmunizationRecommendation"))
- return parseImmunizationRecommendation(xpp);
- else if (type.equals("ImplementationGuide"))
- return parseImplementationGuide(xpp);
- else if (type.equals("Library"))
- return parseLibrary(xpp);
- else if (type.equals("Linkage"))
- return parseLinkage(xpp);
- else if (type.equals("List"))
- return parseListResource(xpp);
- else if (type.equals("Location"))
- return parseLocation(xpp);
- else if (type.equals("Measure"))
- return parseMeasure(xpp);
- else if (type.equals("MeasureReport"))
- return parseMeasureReport(xpp);
- else if (type.equals("Media"))
- return parseMedia(xpp);
- else if (type.equals("Medication"))
- return parseMedication(xpp);
- else if (type.equals("MedicationAdministration"))
- return parseMedicationAdministration(xpp);
- else if (type.equals("MedicationDispense"))
- return parseMedicationDispense(xpp);
- else if (type.equals("MedicationOrder"))
- return parseMedicationOrder(xpp);
- else if (type.equals("MedicationStatement"))
- return parseMedicationStatement(xpp);
- else if (type.equals("MessageHeader"))
- return parseMessageHeader(xpp);
- else if (type.equals("ModuleDefinition"))
- return parseModuleDefinition(xpp);
- else if (type.equals("NamingSystem"))
- return parseNamingSystem(xpp);
- else if (type.equals("NutritionOrder"))
- return parseNutritionOrder(xpp);
- else if (type.equals("Observation"))
- return parseObservation(xpp);
- else if (type.equals("OperationDefinition"))
- return parseOperationDefinition(xpp);
- else if (type.equals("OperationOutcome"))
- return parseOperationOutcome(xpp);
- else if (type.equals("Order"))
- return parseOrder(xpp);
- else if (type.equals("OrderResponse"))
- return parseOrderResponse(xpp);
- else if (type.equals("OrderSet"))
- return parseOrderSet(xpp);
- else if (type.equals("Organization"))
- return parseOrganization(xpp);
- else if (type.equals("Patient"))
- return parsePatient(xpp);
- else if (type.equals("PaymentNotice"))
- return parsePaymentNotice(xpp);
- else if (type.equals("PaymentReconciliation"))
- return parsePaymentReconciliation(xpp);
- else if (type.equals("Person"))
- return parsePerson(xpp);
- else if (type.equals("Practitioner"))
- return parsePractitioner(xpp);
- else if (type.equals("PractitionerRole"))
- return parsePractitionerRole(xpp);
- else if (type.equals("Procedure"))
- return parseProcedure(xpp);
- else if (type.equals("ProcedureRequest"))
- return parseProcedureRequest(xpp);
- else if (type.equals("ProcessRequest"))
- return parseProcessRequest(xpp);
- else if (type.equals("ProcessResponse"))
- return parseProcessResponse(xpp);
- else if (type.equals("Protocol"))
- return parseProtocol(xpp);
- else if (type.equals("Provenance"))
- return parseProvenance(xpp);
- else if (type.equals("Questionnaire"))
- return parseQuestionnaire(xpp);
- else if (type.equals("QuestionnaireResponse"))
- return parseQuestionnaireResponse(xpp);
- else if (type.equals("ReferralRequest"))
- return parseReferralRequest(xpp);
- else if (type.equals("RelatedPerson"))
- return parseRelatedPerson(xpp);
- else if (type.equals("RiskAssessment"))
- return parseRiskAssessment(xpp);
- else if (type.equals("Schedule"))
- return parseSchedule(xpp);
- else if (type.equals("SearchParameter"))
- return parseSearchParameter(xpp);
- else if (type.equals("Sequence"))
- return parseSequence(xpp);
- else if (type.equals("Slot"))
- return parseSlot(xpp);
- else if (type.equals("Specimen"))
- return parseSpecimen(xpp);
- else if (type.equals("StructureDefinition"))
- return parseStructureDefinition(xpp);
- else if (type.equals("StructureMap"))
- return parseStructureMap(xpp);
- else if (type.equals("Subscription"))
- return parseSubscription(xpp);
- else if (type.equals("Substance"))
- return parseSubstance(xpp);
- else if (type.equals("SupplyDelivery"))
- return parseSupplyDelivery(xpp);
- else if (type.equals("SupplyRequest"))
- return parseSupplyRequest(xpp);
- else if (type.equals("Task"))
- return parseTask(xpp);
- else if (type.equals("TestScript"))
- return parseTestScript(xpp);
- else if (type.equals("ValueSet"))
- return parseValueSet(xpp);
- else if (type.equals("VisionPrescription"))
- return parseVisionPrescription(xpp);
- else if (type.equals("date"))
- return parseDate(xpp);
- else if (type.equals("dateTime"))
- return parseDateTime(xpp);
- else if (type.equals("code"))
- return parseCode(xpp);
- else if (type.equals("string"))
- return parseString(xpp);
- else if (type.equals("integer"))
- return parseInteger(xpp);
- else if (type.equals("oid"))
- return parseOid(xpp);
- else if (type.equals("uri"))
- return parseUri(xpp);
- else if (type.equals("uuid"))
- return parseUuid(xpp);
- else if (type.equals("instant"))
- return parseInstant(xpp);
- else if (type.equals("boolean"))
- return parseBoolean(xpp);
- else if (type.equals("base64Binary"))
- return parseBase64Binary(xpp);
- else if (type.equals("unsignedInt"))
- return parseUnsignedInt(xpp);
- else if (type.equals("markdown"))
- return parseMarkdown(xpp);
- else if (type.equals("time"))
- return parseTime(xpp);
- else if (type.equals("id"))
- return parseId(xpp);
- else if (type.equals("positiveInt"))
- return parsePositiveInt(xpp);
- else if (type.equals("decimal"))
- return parseDecimal(xpp);
- throw new FHIRFormatError("Unknown type "+type);
- }
-
- private boolean nameIsTypeName(XmlPullParser xpp, String prefix) {
- if (xpp.getName().equals(prefix+"Reference"))
- return true;
- if (xpp.getName().equals(prefix+"Quantity"))
- return true;
- if (xpp.getName().equals(prefix+"Period"))
- return true;
- if (xpp.getName().equals(prefix+"Attachment"))
- return true;
- if (xpp.getName().equals(prefix+"Duration"))
- return true;
- if (xpp.getName().equals(prefix+"Count"))
- return true;
- if (xpp.getName().equals(prefix+"Range"))
- return true;
- if (xpp.getName().equals(prefix+"Annotation"))
- return true;
- if (xpp.getName().equals(prefix+"Money"))
- return true;
- if (xpp.getName().equals(prefix+"Identifier"))
- return true;
- if (xpp.getName().equals(prefix+"Coding"))
- return true;
- if (xpp.getName().equals(prefix+"Signature"))
- return true;
- if (xpp.getName().equals(prefix+"SampledData"))
- return true;
- if (xpp.getName().equals(prefix+"Ratio"))
- return true;
- if (xpp.getName().equals(prefix+"Distance"))
- return true;
- if (xpp.getName().equals(prefix+"Age"))
- return true;
- if (xpp.getName().equals(prefix+"CodeableConcept"))
- return true;
- if (xpp.getName().equals(prefix+"SimpleQuantity"))
- return true;
- if (xpp.getName().equals(prefix+"HumanName"))
- return true;
- if (xpp.getName().equals(prefix+"ContactPoint"))
- return true;
- if (xpp.getName().equals(prefix+"Meta"))
- return true;
- if (xpp.getName().equals(prefix+"Address"))
- return true;
- if (xpp.getName().equals(prefix+"TriggerDefinition"))
- return true;
- if (xpp.getName().equals(prefix+"ModuleMetadata"))
- return true;
- if (xpp.getName().equals(prefix+"Timing"))
- return true;
- if (xpp.getName().equals(prefix+"ElementDefinition"))
- return true;
- if (xpp.getName().equals(prefix+"DataRequirement"))
- return true;
- if (xpp.getName().equals(prefix+"ActionDefinition"))
- return true;
- if (xpp.getName().equals(prefix+"ParameterDefinition"))
- return true;
- if (xpp.getName().equals(prefix+"Parameters"))
- return true;
- if (xpp.getName().equals(prefix+"Account"))
- return true;
- if (xpp.getName().equals(prefix+"AllergyIntolerance"))
- return true;
- if (xpp.getName().equals(prefix+"Appointment"))
- return true;
- if (xpp.getName().equals(prefix+"AppointmentResponse"))
- return true;
- if (xpp.getName().equals(prefix+"AuditEvent"))
- return true;
- if (xpp.getName().equals(prefix+"Basic"))
- return true;
- if (xpp.getName().equals(prefix+"Binary"))
- return true;
- if (xpp.getName().equals(prefix+"BodySite"))
- return true;
- if (xpp.getName().equals(prefix+"Bundle"))
- return true;
- if (xpp.getName().equals(prefix+"CarePlan"))
- return true;
- if (xpp.getName().equals(prefix+"CareTeam"))
- return true;
- if (xpp.getName().equals(prefix+"Claim"))
- return true;
- if (xpp.getName().equals(prefix+"ClaimResponse"))
- return true;
- if (xpp.getName().equals(prefix+"ClinicalImpression"))
- return true;
- if (xpp.getName().equals(prefix+"CodeSystem"))
- return true;
- if (xpp.getName().equals(prefix+"Communication"))
- return true;
- if (xpp.getName().equals(prefix+"CommunicationRequest"))
- return true;
- if (xpp.getName().equals(prefix+"CompartmentDefinition"))
- return true;
- if (xpp.getName().equals(prefix+"Composition"))
- return true;
- if (xpp.getName().equals(prefix+"ConceptMap"))
- return true;
- if (xpp.getName().equals(prefix+"Condition"))
- return true;
- if (xpp.getName().equals(prefix+"Conformance"))
- return true;
- if (xpp.getName().equals(prefix+"Consent"))
- return true;
- if (xpp.getName().equals(prefix+"Contract"))
- return true;
- if (xpp.getName().equals(prefix+"Coverage"))
- return true;
- if (xpp.getName().equals(prefix+"DataElement"))
- return true;
- if (xpp.getName().equals(prefix+"DecisionSupportRule"))
- return true;
- if (xpp.getName().equals(prefix+"DecisionSupportServiceModule"))
- return true;
- if (xpp.getName().equals(prefix+"DetectedIssue"))
- return true;
- if (xpp.getName().equals(prefix+"Device"))
- return true;
- if (xpp.getName().equals(prefix+"DeviceComponent"))
- return true;
- if (xpp.getName().equals(prefix+"DeviceMetric"))
- return true;
- if (xpp.getName().equals(prefix+"DeviceUseRequest"))
- return true;
- if (xpp.getName().equals(prefix+"DeviceUseStatement"))
- return true;
- if (xpp.getName().equals(prefix+"DiagnosticOrder"))
- return true;
- if (xpp.getName().equals(prefix+"DiagnosticReport"))
- return true;
- if (xpp.getName().equals(prefix+"DocumentManifest"))
- return true;
- if (xpp.getName().equals(prefix+"DocumentReference"))
- return true;
- if (xpp.getName().equals(prefix+"EligibilityRequest"))
- return true;
- if (xpp.getName().equals(prefix+"EligibilityResponse"))
- return true;
- if (xpp.getName().equals(prefix+"Encounter"))
- return true;
- if (xpp.getName().equals(prefix+"Endpoint"))
- return true;
- if (xpp.getName().equals(prefix+"EnrollmentRequest"))
- return true;
- if (xpp.getName().equals(prefix+"EnrollmentResponse"))
- return true;
- if (xpp.getName().equals(prefix+"EpisodeOfCare"))
- return true;
- if (xpp.getName().equals(prefix+"ExpansionProfile"))
- return true;
- if (xpp.getName().equals(prefix+"ExplanationOfBenefit"))
- return true;
- if (xpp.getName().equals(prefix+"FamilyMemberHistory"))
- return true;
- if (xpp.getName().equals(prefix+"Flag"))
- return true;
- if (xpp.getName().equals(prefix+"Goal"))
- return true;
- if (xpp.getName().equals(prefix+"Group"))
- return true;
- if (xpp.getName().equals(prefix+"GuidanceResponse"))
- return true;
- if (xpp.getName().equals(prefix+"HealthcareService"))
- return true;
- if (xpp.getName().equals(prefix+"ImagingExcerpt"))
- return true;
- if (xpp.getName().equals(prefix+"ImagingObjectSelection"))
- return true;
- if (xpp.getName().equals(prefix+"ImagingStudy"))
- return true;
- if (xpp.getName().equals(prefix+"Immunization"))
- return true;
- if (xpp.getName().equals(prefix+"ImmunizationRecommendation"))
- return true;
- if (xpp.getName().equals(prefix+"ImplementationGuide"))
- return true;
- if (xpp.getName().equals(prefix+"Library"))
- return true;
- if (xpp.getName().equals(prefix+"Linkage"))
- return true;
- if (xpp.getName().equals(prefix+"List"))
- return true;
- if (xpp.getName().equals(prefix+"Location"))
- return true;
- if (xpp.getName().equals(prefix+"Measure"))
- return true;
- if (xpp.getName().equals(prefix+"MeasureReport"))
- return true;
- if (xpp.getName().equals(prefix+"Media"))
- return true;
- if (xpp.getName().equals(prefix+"Medication"))
- return true;
- if (xpp.getName().equals(prefix+"MedicationAdministration"))
- return true;
- if (xpp.getName().equals(prefix+"MedicationDispense"))
- return true;
- if (xpp.getName().equals(prefix+"MedicationOrder"))
- return true;
- if (xpp.getName().equals(prefix+"MedicationStatement"))
- return true;
- if (xpp.getName().equals(prefix+"MessageHeader"))
- return true;
- if (xpp.getName().equals(prefix+"ModuleDefinition"))
- return true;
- if (xpp.getName().equals(prefix+"NamingSystem"))
- return true;
- if (xpp.getName().equals(prefix+"NutritionOrder"))
- return true;
- if (xpp.getName().equals(prefix+"Observation"))
- return true;
- if (xpp.getName().equals(prefix+"OperationDefinition"))
- return true;
- if (xpp.getName().equals(prefix+"OperationOutcome"))
- return true;
- if (xpp.getName().equals(prefix+"Order"))
- return true;
- if (xpp.getName().equals(prefix+"OrderResponse"))
- return true;
- if (xpp.getName().equals(prefix+"OrderSet"))
- return true;
- if (xpp.getName().equals(prefix+"Organization"))
- return true;
- if (xpp.getName().equals(prefix+"Patient"))
- return true;
- if (xpp.getName().equals(prefix+"PaymentNotice"))
- return true;
- if (xpp.getName().equals(prefix+"PaymentReconciliation"))
- return true;
- if (xpp.getName().equals(prefix+"Person"))
- return true;
- if (xpp.getName().equals(prefix+"Practitioner"))
- return true;
- if (xpp.getName().equals(prefix+"PractitionerRole"))
- return true;
- if (xpp.getName().equals(prefix+"Procedure"))
- return true;
- if (xpp.getName().equals(prefix+"ProcedureRequest"))
- return true;
- if (xpp.getName().equals(prefix+"ProcessRequest"))
- return true;
- if (xpp.getName().equals(prefix+"ProcessResponse"))
- return true;
- if (xpp.getName().equals(prefix+"Protocol"))
- return true;
- if (xpp.getName().equals(prefix+"Provenance"))
- return true;
- if (xpp.getName().equals(prefix+"Questionnaire"))
- return true;
- if (xpp.getName().equals(prefix+"QuestionnaireResponse"))
- return true;
- if (xpp.getName().equals(prefix+"ReferralRequest"))
- return true;
- if (xpp.getName().equals(prefix+"RelatedPerson"))
- return true;
- if (xpp.getName().equals(prefix+"RiskAssessment"))
- return true;
- if (xpp.getName().equals(prefix+"Schedule"))
- return true;
- if (xpp.getName().equals(prefix+"SearchParameter"))
- return true;
- if (xpp.getName().equals(prefix+"Sequence"))
- return true;
- if (xpp.getName().equals(prefix+"Slot"))
- return true;
- if (xpp.getName().equals(prefix+"Specimen"))
- return true;
- if (xpp.getName().equals(prefix+"StructureDefinition"))
- return true;
- if (xpp.getName().equals(prefix+"StructureMap"))
- return true;
- if (xpp.getName().equals(prefix+"Subscription"))
- return true;
- if (xpp.getName().equals(prefix+"Substance"))
- return true;
- if (xpp.getName().equals(prefix+"SupplyDelivery"))
- return true;
- if (xpp.getName().equals(prefix+"SupplyRequest"))
- return true;
- if (xpp.getName().equals(prefix+"Task"))
- return true;
- if (xpp.getName().equals(prefix+"TestScript"))
- return true;
- if (xpp.getName().equals(prefix+"ValueSet"))
- return true;
- if (xpp.getName().equals(prefix+"VisionPrescription"))
- return true;
- if (xpp.getName().equals(prefix+"Date"))
- return true;
- if (xpp.getName().equals(prefix+"DateTime"))
- return true;
- if (xpp.getName().equals(prefix+"Code"))
- return true;
- if (xpp.getName().equals(prefix+"String"))
- return true;
- if (xpp.getName().equals(prefix+"Integer"))
- return true;
- if (xpp.getName().equals(prefix+"Oid"))
- return true;
- if (xpp.getName().equals(prefix+"Uri"))
- return true;
- if (xpp.getName().equals(prefix+"Uuid"))
- return true;
- if (xpp.getName().equals(prefix+"Instant"))
- return true;
- if (xpp.getName().equals(prefix+"Boolean"))
- return true;
- if (xpp.getName().equals(prefix+"Base64Binary"))
- return true;
- if (xpp.getName().equals(prefix+"UnsignedInt"))
- return true;
- if (xpp.getName().equals(prefix+"Markdown"))
- return true;
- if (xpp.getName().equals(prefix+"Time"))
- return true;
- if (xpp.getName().equals(prefix+"Id"))
- return true;
- if (xpp.getName().equals(prefix+"PositiveInt"))
- return true;
- if (xpp.getName().equals(prefix+"Decimal"))
- return true;
- return false;
- }
- protected void composeElementElements(Element element) throws IOException {
- for (Extension e : element.getExtension()) {
- composeExtension("extension", e);
- }
- }
-
- protected void composeBackboneElements(BackboneElement element) throws IOException {
- composeElementElements(element);
- for (Extension e : element.getModifierExtension()) {
- composeExtension("modifierExtension", e);
- }
- }
-
- protected > void composeEnumeration(String name, Enumeration value, EnumFactory e) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || value.getValue() != null)) {
- composeElementAttributes(value);
- if (value.getValue() != null)
- xml.attribute("value", e.toCode(value.getValue()));
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDate(String name, DateType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || value.getValue() != null)) {// date
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDateTime(String name, DateTimeType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || value.getValue() != null)) {// dateTime
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCode(String name, CodeType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || !Utilities.noString(value.getValue()))) {// code
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeString(String name, StringType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || !Utilities.noString(value.getValue()))) {// string
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeInteger(String name, IntegerType value) throws IOException {
- if (value != null) { // integer
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOid(String name, OidType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || !Utilities.noString(value.getValue()))) {// oid
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeUri(String name, UriType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || value.getValue() != null)) {// uri
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeUuid(String name, UuidType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || !Utilities.noString(value.getValue()))) {// uuid
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeInstant(String name, InstantType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || value.getValue() != null)) {// instant
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeBoolean(String name, BooleanType value) throws IOException {
- if (value != null) { // boolean
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeBase64Binary(String name, Base64BinaryType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || value.getValue() != null)) {// base64Binary
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeUnsignedInt(String name, UnsignedIntType value) throws IOException {
- if (value != null) { // unsignedInt
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMarkdown(String name, MarkdownType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || !Utilities.noString(value.getValue()))) {// markdown
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTime(String name, TimeType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || !Utilities.noString(value.getValue()))) {// time
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeId(String name, IdType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || !Utilities.noString(value.getValue()))) {// id
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePositiveInt(String name, PositiveIntType value) throws IOException {
- if (value != null) { // positiveInt
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDecimal(String name, DecimalType value) throws IOException {
- if (value != null && (!Utilities.noString(value.getId()) || ExtensionHelper.hasExtensions(value) || value.getValue() != null)) {// decimal
- composeElementAttributes(value);
- if (value.asStringValue() != null)
- xml.attribute("value", value.asStringValue());
-
- xml.enter(FHIR_NS, name);
- composeElementElements(value);
- composeElementClose(value);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExtension(String name, Extension element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- if (element.hasUrlElement())
- xml.attribute("url", element.getUrlElement().getValue());
- xml.enter(FHIR_NS, name);
- composeExtensionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExtensionElements(Extension element) throws IOException {
- composeElementElements(element);
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeNarrative(String name, Narrative element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeNarrativeElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeNarrativeElements(Narrative element) throws IOException {
- composeElementElements(element);
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Narrative.NarrativeStatusEnumFactory());
- if (element.hasDiv()) {
- composeXhtml("div", element.getDiv());
- }
- }
-
- protected void composeReference(String name, Reference element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeReferenceElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeReferenceElements(Reference element) throws IOException {
- composeElementElements(element);
- if (element.hasReferenceElement()) {
- composeString("reference", element.getReferenceElement());
- }
- if (element.hasDisplayElement()) {
- composeString("display", element.getDisplayElement());
- }
- }
-
- protected void composeQuantity(String name, Quantity element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeQuantityElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeQuantityElements(Quantity element) throws IOException {
- composeElementElements(element);
- if (element.hasValueElement()) {
- composeDecimal("value", element.getValueElement());
- }
- if (element.hasComparatorElement())
- composeEnumeration("comparator", element.getComparatorElement(), new Quantity.QuantityComparatorEnumFactory());
- if (element.hasUnitElement()) {
- composeString("unit", element.getUnitElement());
- }
- if (element.hasSystemElement()) {
- composeUri("system", element.getSystemElement());
- }
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- }
-
- protected void composePeriod(String name, Period element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composePeriodElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePeriodElements(Period element) throws IOException {
- composeElementElements(element);
- if (element.hasStartElement()) {
- composeDateTime("start", element.getStartElement());
- }
- if (element.hasEndElement()) {
- composeDateTime("end", element.getEndElement());
- }
- }
-
- protected void composeAttachment(String name, Attachment element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAttachmentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAttachmentElements(Attachment element) throws IOException {
- composeElementElements(element);
- if (element.hasContentTypeElement()) {
- composeCode("contentType", element.getContentTypeElement());
- }
- if (element.hasLanguageElement()) {
- composeCode("language", element.getLanguageElement());
- }
- if (element.hasDataElement()) {
- composeBase64Binary("data", element.getDataElement());
- }
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasSizeElement()) {
- composeUnsignedInt("size", element.getSizeElement());
- }
- if (element.hasHashElement()) {
- composeBase64Binary("hash", element.getHashElement());
- }
- if (element.hasTitleElement()) {
- composeString("title", element.getTitleElement());
- }
- if (element.hasCreationElement()) {
- composeDateTime("creation", element.getCreationElement());
- }
- }
-
- protected void composeDuration(String name, Duration element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDurationElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDurationElements(Duration element) throws IOException {
- composeQuantityElements(element);
- }
-
- protected void composeCount(String name, Count element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCountElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCountElements(Count element) throws IOException {
- composeQuantityElements(element);
- }
-
- protected void composeRange(String name, Range element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeRangeElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeRangeElements(Range element) throws IOException {
- composeElementElements(element);
- if (element.hasLow()) {
- composeSimpleQuantity("low", element.getLow());
- }
- if (element.hasHigh()) {
- composeSimpleQuantity("high", element.getHigh());
- }
- }
-
- protected void composeAnnotation(String name, Annotation element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAnnotationElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAnnotationElements(Annotation element) throws IOException {
- composeElementElements(element);
- if (element.hasAuthor()) {
- composeType("author", element.getAuthor());
- } if (element.hasTimeElement()) {
- composeDateTime("time", element.getTimeElement());
- }
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- }
-
- protected void composeMoney(String name, Money element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMoneyElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMoneyElements(Money element) throws IOException {
- composeQuantityElements(element);
- }
-
- protected void composeIdentifier(String name, Identifier element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeIdentifierElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeIdentifierElements(Identifier element) throws IOException {
- composeElementElements(element);
- if (element.hasUseElement())
- composeEnumeration("use", element.getUseElement(), new Identifier.IdentifierUseEnumFactory());
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasSystemElement()) {
- composeUri("system", element.getSystemElement());
- }
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasAssigner()) {
- composeReference("assigner", element.getAssigner());
- }
- }
-
- protected void composeCoding(String name, Coding element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCodingElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCodingElements(Coding element) throws IOException {
- composeElementElements(element);
- if (element.hasSystemElement()) {
- composeUri("system", element.getSystemElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasDisplayElement()) {
- composeString("display", element.getDisplayElement());
- }
- if (element.hasUserSelectedElement()) {
- composeBoolean("userSelected", element.getUserSelectedElement());
- }
- }
-
- protected void composeSignature(String name, Signature element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSignatureElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSignatureElements(Signature element) throws IOException {
- composeElementElements(element);
- if (element.hasType()) {
- for (Coding e : element.getType())
- composeCoding("type", e);
- }
- if (element.hasWhenElement()) {
- composeInstant("when", element.getWhenElement());
- }
- if (element.hasWho()) {
- composeType("who", element.getWho());
- } if (element.hasContentTypeElement()) {
- composeCode("contentType", element.getContentTypeElement());
- }
- if (element.hasBlobElement()) {
- composeBase64Binary("blob", element.getBlobElement());
- }
- }
-
- protected void composeSampledData(String name, SampledData element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSampledDataElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSampledDataElements(SampledData element) throws IOException {
- composeElementElements(element);
- if (element.hasOrigin()) {
- composeSimpleQuantity("origin", element.getOrigin());
- }
- if (element.hasPeriodElement()) {
- composeDecimal("period", element.getPeriodElement());
- }
- if (element.hasFactorElement()) {
- composeDecimal("factor", element.getFactorElement());
- }
- if (element.hasLowerLimitElement()) {
- composeDecimal("lowerLimit", element.getLowerLimitElement());
- }
- if (element.hasUpperLimitElement()) {
- composeDecimal("upperLimit", element.getUpperLimitElement());
- }
- if (element.hasDimensionsElement()) {
- composePositiveInt("dimensions", element.getDimensionsElement());
- }
- if (element.hasDataElement()) {
- composeString("data", element.getDataElement());
- }
- }
-
- protected void composeRatio(String name, Ratio element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeRatioElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeRatioElements(Ratio element) throws IOException {
- composeElementElements(element);
- if (element.hasNumerator()) {
- composeQuantity("numerator", element.getNumerator());
- }
- if (element.hasDenominator()) {
- composeQuantity("denominator", element.getDenominator());
- }
- }
-
- protected void composeDistance(String name, Distance element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDistanceElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDistanceElements(Distance element) throws IOException {
- composeQuantityElements(element);
- }
-
- protected void composeAge(String name, Age element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAgeElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAgeElements(Age element) throws IOException {
- composeQuantityElements(element);
- }
-
- protected void composeCodeableConcept(String name, CodeableConcept element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCodeableConceptElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCodeableConceptElements(CodeableConcept element) throws IOException {
- composeElementElements(element);
- if (element.hasCoding()) {
- for (Coding e : element.getCoding())
- composeCoding("coding", e);
- }
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- }
-
- protected void composeSimpleQuantity(String name, SimpleQuantity element) throws IOException {
- if (element != null) {
- composeTypeAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSimpleQuantityElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSimpleQuantityElements(SimpleQuantity element) throws IOException {
- composeElementElements(element);
- if (element.hasValueElement()) {
- composeDecimal("value", element.getValueElement());
- }
- if (element.hasComparatorElement())
- composeEnumeration("comparator", element.getComparatorElement(), new SimpleQuantity.QuantityComparatorEnumFactory());
- if (element.hasUnitElement()) {
- composeString("unit", element.getUnitElement());
- }
- if (element.hasSystemElement()) {
- composeUri("system", element.getSystemElement());
- }
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- }
-
- protected void composeHumanName(String name, HumanName element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeHumanNameElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeHumanNameElements(HumanName element) throws IOException {
- composeElementElements(element);
- if (element.hasUseElement())
- composeEnumeration("use", element.getUseElement(), new HumanName.NameUseEnumFactory());
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- if (element.hasFamily()) {
- for (StringType e : element.getFamily())
- composeString("family", e);
- }
- if (element.hasGiven()) {
- for (StringType e : element.getGiven())
- composeString("given", e);
- }
- if (element.hasPrefix()) {
- for (StringType e : element.getPrefix())
- composeString("prefix", e);
- }
- if (element.hasSuffix()) {
- for (StringType e : element.getSuffix())
- composeString("suffix", e);
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composeContactPoint(String name, ContactPoint element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeContactPointElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeContactPointElements(ContactPoint element) throws IOException {
- composeElementElements(element);
- if (element.hasSystemElement())
- composeEnumeration("system", element.getSystemElement(), new ContactPoint.ContactPointSystemEnumFactory());
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- if (element.hasUseElement())
- composeEnumeration("use", element.getUseElement(), new ContactPoint.ContactPointUseEnumFactory());
- if (element.hasRankElement()) {
- composePositiveInt("rank", element.getRankElement());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composeMeta(String name, Meta element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMetaElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMetaElements(Meta element) throws IOException {
- composeElementElements(element);
- if (element.hasVersionIdElement()) {
- composeId("versionId", element.getVersionIdElement());
- }
- if (element.hasLastUpdatedElement()) {
- composeInstant("lastUpdated", element.getLastUpdatedElement());
- }
- if (element.hasProfile()) {
- for (UriType e : element.getProfile())
- composeUri("profile", e);
- }
- if (element.hasSecurity()) {
- for (Coding e : element.getSecurity())
- composeCoding("security", e);
- }
- if (element.hasTag()) {
- for (Coding e : element.getTag())
- composeCoding("tag", e);
- }
- }
-
- protected void composeAddress(String name, Address element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAddressElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAddressElements(Address element) throws IOException {
- composeElementElements(element);
- if (element.hasUseElement())
- composeEnumeration("use", element.getUseElement(), new Address.AddressUseEnumFactory());
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Address.AddressTypeEnumFactory());
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- if (element.hasLine()) {
- for (StringType e : element.getLine())
- composeString("line", e);
- }
- if (element.hasCityElement()) {
- composeString("city", element.getCityElement());
- }
- if (element.hasDistrictElement()) {
- composeString("district", element.getDistrictElement());
- }
- if (element.hasStateElement()) {
- composeString("state", element.getStateElement());
- }
- if (element.hasPostalCodeElement()) {
- composeString("postalCode", element.getPostalCodeElement());
- }
- if (element.hasCountryElement()) {
- composeString("country", element.getCountryElement());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composeTriggerDefinition(String name, TriggerDefinition element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTriggerDefinitionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTriggerDefinitionElements(TriggerDefinition element) throws IOException {
- composeElementElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new TriggerDefinition.TriggerTypeEnumFactory());
- if (element.hasEventNameElement()) {
- composeString("eventName", element.getEventNameElement());
- }
- if (element.hasEventTiming()) {
- composeType("eventTiming", element.getEventTiming());
- } if (element.hasEventData()) {
- composeDataRequirement("eventData", element.getEventData());
- }
- }
-
- protected void composeModuleMetadata(String name, ModuleMetadata element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleMetadataElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleMetadataElements(ModuleMetadata element) throws IOException {
- composeElementElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTitleElement()) {
- composeString("title", element.getTitleElement());
- }
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new ModuleMetadata.ModuleMetadataTypeEnumFactory());
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new ModuleMetadata.ModuleMetadataStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasPurposeElement()) {
- composeString("purpose", element.getPurposeElement());
- }
- if (element.hasUsageElement()) {
- composeString("usage", element.getUsageElement());
- }
- if (element.hasPublicationDateElement()) {
- composeDate("publicationDate", element.getPublicationDateElement());
- }
- if (element.hasLastReviewDateElement()) {
- composeDate("lastReviewDate", element.getLastReviewDateElement());
- }
- if (element.hasEffectivePeriod()) {
- composePeriod("effectivePeriod", element.getEffectivePeriod());
- }
- if (element.hasCoverage()) {
- for (ModuleMetadata.ModuleMetadataCoverageComponent e : element.getCoverage())
- composeModuleMetadataModuleMetadataCoverageComponent("coverage", e);
- }
- if (element.hasTopic()) {
- for (CodeableConcept e : element.getTopic())
- composeCodeableConcept("topic", e);
- }
- if (element.hasContributor()) {
- for (ModuleMetadata.ModuleMetadataContributorComponent e : element.getContributor())
- composeModuleMetadataModuleMetadataContributorComponent("contributor", e);
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (ModuleMetadata.ModuleMetadataContactComponent e : element.getContact())
- composeModuleMetadataModuleMetadataContactComponent("contact", e);
- }
- if (element.hasCopyrightElement()) {
- composeString("copyright", element.getCopyrightElement());
- }
- if (element.hasRelatedResource()) {
- for (ModuleMetadata.ModuleMetadataRelatedResourceComponent e : element.getRelatedResource())
- composeModuleMetadataModuleMetadataRelatedResourceComponent("relatedResource", e);
- }
- }
-
- protected void composeModuleMetadataModuleMetadataCoverageComponent(String name, ModuleMetadata.ModuleMetadataCoverageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleMetadataModuleMetadataCoverageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleMetadataModuleMetadataCoverageComponentElements(ModuleMetadata.ModuleMetadataCoverageComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasFocus()) {
- composeCoding("focus", element.getFocus());
- }
- if (element.hasValue()) {
- composeCodeableConcept("value", element.getValue());
- }
- }
-
- protected void composeModuleMetadataModuleMetadataContributorComponent(String name, ModuleMetadata.ModuleMetadataContributorComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleMetadataModuleMetadataContributorComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleMetadataModuleMetadataContributorComponentElements(ModuleMetadata.ModuleMetadataContributorComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new ModuleMetadata.ModuleMetadataContributorTypeEnumFactory());
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasContact()) {
- for (ModuleMetadata.ModuleMetadataContributorContactComponent e : element.getContact())
- composeModuleMetadataModuleMetadataContributorContactComponent("contact", e);
- }
- }
-
- protected void composeModuleMetadataModuleMetadataContributorContactComponent(String name, ModuleMetadata.ModuleMetadataContributorContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleMetadataModuleMetadataContributorContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleMetadataModuleMetadataContributorContactComponentElements(ModuleMetadata.ModuleMetadataContributorContactComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeModuleMetadataModuleMetadataContactComponent(String name, ModuleMetadata.ModuleMetadataContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleMetadataModuleMetadataContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleMetadataModuleMetadataContactComponentElements(ModuleMetadata.ModuleMetadataContactComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeModuleMetadataModuleMetadataRelatedResourceComponent(String name, ModuleMetadata.ModuleMetadataRelatedResourceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleMetadataModuleMetadataRelatedResourceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleMetadataModuleMetadataRelatedResourceComponentElements(ModuleMetadata.ModuleMetadataRelatedResourceComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new ModuleMetadata.ModuleMetadataResourceTypeEnumFactory());
- if (element.hasDocument()) {
- composeAttachment("document", element.getDocument());
- }
- if (element.hasResource()) {
- composeReference("resource", element.getResource());
- }
- }
-
- protected void composeTiming(String name, Timing element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTimingElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTimingElements(Timing element) throws IOException {
- composeElementElements(element);
- if (element.hasEvent()) {
- for (DateTimeType e : element.getEvent())
- composeDateTime("event", e);
- }
- if (element.hasRepeat()) {
- composeTimingTimingRepeatComponent("repeat", element.getRepeat());
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- }
-
- protected void composeTimingTimingRepeatComponent(String name, Timing.TimingRepeatComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTimingTimingRepeatComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTimingTimingRepeatComponentElements(Timing.TimingRepeatComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasBounds()) {
- composeType("bounds", element.getBounds());
- } if (element.hasCountElement()) {
- composeInteger("count", element.getCountElement());
- }
- if (element.hasCountMaxElement()) {
- composeInteger("countMax", element.getCountMaxElement());
- }
- if (element.hasDurationElement()) {
- composeDecimal("duration", element.getDurationElement());
- }
- if (element.hasDurationMaxElement()) {
- composeDecimal("durationMax", element.getDurationMaxElement());
- }
- if (element.hasDurationUnitElement())
- composeEnumeration("durationUnit", element.getDurationUnitElement(), new Timing.UnitsOfTimeEnumFactory());
- if (element.hasFrequencyElement()) {
- composeInteger("frequency", element.getFrequencyElement());
- }
- if (element.hasFrequencyMaxElement()) {
- composeInteger("frequencyMax", element.getFrequencyMaxElement());
- }
- if (element.hasPeriodElement()) {
- composeDecimal("period", element.getPeriodElement());
- }
- if (element.hasPeriodMaxElement()) {
- composeDecimal("periodMax", element.getPeriodMaxElement());
- }
- if (element.hasPeriodUnitElement())
- composeEnumeration("periodUnit", element.getPeriodUnitElement(), new Timing.UnitsOfTimeEnumFactory());
- if (element.hasWhenElement())
- composeEnumeration("when", element.getWhenElement(), new Timing.EventTimingEnumFactory());
- if (element.hasOffsetElement()) {
- composeUnsignedInt("offset", element.getOffsetElement());
- }
- }
-
- protected void composeElementDefinition(String name, ElementDefinition element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeElementDefinitionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeElementDefinitionElements(ElementDefinition element) throws IOException {
- composeElementElements(element);
- if (element.hasPathElement()) {
- composeString("path", element.getPathElement());
- }
- if (element.hasRepresentation())
- for (Enumeration e : element.getRepresentation())
- composeEnumeration("representation", e, new ElementDefinition.PropertyRepresentationEnumFactory());
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasLabelElement()) {
- composeString("label", element.getLabelElement());
- }
- if (element.hasCode()) {
- for (Coding e : element.getCode())
- composeCoding("code", e);
- }
- if (element.hasSlicing()) {
- composeElementDefinitionElementDefinitionSlicingComponent("slicing", element.getSlicing());
- }
- if (element.hasShortElement()) {
- composeString("short", element.getShortElement());
- }
- if (element.hasDefinitionElement()) {
- composeMarkdown("definition", element.getDefinitionElement());
- }
- if (element.hasCommentsElement()) {
- composeMarkdown("comments", element.getCommentsElement());
- }
- if (element.hasRequirementsElement()) {
- composeMarkdown("requirements", element.getRequirementsElement());
- }
- if (element.hasAlias()) {
- for (StringType e : element.getAlias())
- composeString("alias", e);
- }
- if (element.hasMinElement()) {
- composeInteger("min", element.getMinElement());
- }
- if (element.hasMaxElement()) {
- composeString("max", element.getMaxElement());
- }
- if (element.hasBase()) {
- composeElementDefinitionElementDefinitionBaseComponent("base", element.getBase());
- }
- if (element.hasContentReferenceElement()) {
- composeUri("contentReference", element.getContentReferenceElement());
- }
- if (element.hasType()) {
- for (ElementDefinition.TypeRefComponent e : element.getType())
- composeElementDefinitionTypeRefComponent("type", e);
- }
- if (element.hasDefaultValue()) {
- composeType("defaultValue", element.getDefaultValue());
- } if (element.hasMeaningWhenMissingElement()) {
- composeMarkdown("meaningWhenMissing", element.getMeaningWhenMissingElement());
- }
- if (element.hasFixed()) {
- composeType("fixed", element.getFixed());
- } if (element.hasPattern()) {
- composeType("pattern", element.getPattern());
- } if (element.hasExample()) {
- composeType("example", element.getExample());
- } if (element.hasMinValue()) {
- composeType("minValue", element.getMinValue());
- } if (element.hasMaxValue()) {
- composeType("maxValue", element.getMaxValue());
- } if (element.hasMaxLengthElement()) {
- composeInteger("maxLength", element.getMaxLengthElement());
- }
- if (element.hasCondition()) {
- for (IdType e : element.getCondition())
- composeId("condition", e);
- }
- if (element.hasConstraint()) {
- for (ElementDefinition.ElementDefinitionConstraintComponent e : element.getConstraint())
- composeElementDefinitionElementDefinitionConstraintComponent("constraint", e);
- }
- if (element.hasMustSupportElement()) {
- composeBoolean("mustSupport", element.getMustSupportElement());
- }
- if (element.hasIsModifierElement()) {
- composeBoolean("isModifier", element.getIsModifierElement());
- }
- if (element.hasIsSummaryElement()) {
- composeBoolean("isSummary", element.getIsSummaryElement());
- }
- if (element.hasBinding()) {
- composeElementDefinitionElementDefinitionBindingComponent("binding", element.getBinding());
- }
- if (element.hasMapping()) {
- for (ElementDefinition.ElementDefinitionMappingComponent e : element.getMapping())
- composeElementDefinitionElementDefinitionMappingComponent("mapping", e);
- }
- }
-
- protected void composeElementDefinitionElementDefinitionSlicingComponent(String name, ElementDefinition.ElementDefinitionSlicingComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeElementDefinitionElementDefinitionSlicingComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeElementDefinitionElementDefinitionSlicingComponentElements(ElementDefinition.ElementDefinitionSlicingComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasDiscriminator()) {
- for (StringType e : element.getDiscriminator())
- composeString("discriminator", e);
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasOrderedElement()) {
- composeBoolean("ordered", element.getOrderedElement());
- }
- if (element.hasRulesElement())
- composeEnumeration("rules", element.getRulesElement(), new ElementDefinition.SlicingRulesEnumFactory());
- }
-
- protected void composeElementDefinitionElementDefinitionBaseComponent(String name, ElementDefinition.ElementDefinitionBaseComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeElementDefinitionElementDefinitionBaseComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeElementDefinitionElementDefinitionBaseComponentElements(ElementDefinition.ElementDefinitionBaseComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasPathElement()) {
- composeString("path", element.getPathElement());
- }
- if (element.hasMinElement()) {
- composeInteger("min", element.getMinElement());
- }
- if (element.hasMaxElement()) {
- composeString("max", element.getMaxElement());
- }
- }
-
- protected void composeElementDefinitionTypeRefComponent(String name, ElementDefinition.TypeRefComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeElementDefinitionTypeRefComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeElementDefinitionTypeRefComponentElements(ElementDefinition.TypeRefComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasProfile()) {
- for (UriType e : element.getProfile())
- composeUri("profile", e);
- }
- if (element.hasAggregation())
- for (Enumeration e : element.getAggregation())
- composeEnumeration("aggregation", e, new ElementDefinition.AggregationModeEnumFactory());
- if (element.hasVersioningElement())
- composeEnumeration("versioning", element.getVersioningElement(), new ElementDefinition.ReferenceVersionRulesEnumFactory());
- }
-
- protected void composeElementDefinitionElementDefinitionConstraintComponent(String name, ElementDefinition.ElementDefinitionConstraintComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeElementDefinitionElementDefinitionConstraintComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeElementDefinitionElementDefinitionConstraintComponentElements(ElementDefinition.ElementDefinitionConstraintComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasKeyElement()) {
- composeId("key", element.getKeyElement());
- }
- if (element.hasRequirementsElement()) {
- composeString("requirements", element.getRequirementsElement());
- }
- if (element.hasSeverityElement())
- composeEnumeration("severity", element.getSeverityElement(), new ElementDefinition.ConstraintSeverityEnumFactory());
- if (element.hasHumanElement()) {
- composeString("human", element.getHumanElement());
- }
- if (element.hasExpressionElement()) {
- composeString("expression", element.getExpressionElement());
- }
- if (element.hasXpathElement()) {
- composeString("xpath", element.getXpathElement());
- }
- }
-
- protected void composeElementDefinitionElementDefinitionBindingComponent(String name, ElementDefinition.ElementDefinitionBindingComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeElementDefinitionElementDefinitionBindingComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeElementDefinitionElementDefinitionBindingComponentElements(ElementDefinition.ElementDefinitionBindingComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasStrengthElement())
- composeEnumeration("strength", element.getStrengthElement(), new Enumerations.BindingStrengthEnumFactory());
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasValueSet()) {
- composeType("valueSet", element.getValueSet());
- } }
-
- protected void composeElementDefinitionElementDefinitionMappingComponent(String name, ElementDefinition.ElementDefinitionMappingComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeElementDefinitionElementDefinitionMappingComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeElementDefinitionElementDefinitionMappingComponentElements(ElementDefinition.ElementDefinitionMappingComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasIdentityElement()) {
- composeId("identity", element.getIdentityElement());
- }
- if (element.hasLanguageElement()) {
- composeCode("language", element.getLanguageElement());
- }
- if (element.hasMapElement()) {
- composeString("map", element.getMapElement());
- }
- }
-
- protected void composeDataRequirement(String name, DataRequirement element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDataRequirementElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDataRequirementElements(DataRequirement element) throws IOException {
- composeElementElements(element);
- if (element.hasTypeElement()) {
- composeCode("type", element.getTypeElement());
- }
- if (element.hasProfile()) {
- composeReference("profile", element.getProfile());
- }
- if (element.hasMustSupport()) {
- for (StringType e : element.getMustSupport())
- composeString("mustSupport", e);
- }
- if (element.hasCodeFilter()) {
- for (DataRequirement.DataRequirementCodeFilterComponent e : element.getCodeFilter())
- composeDataRequirementDataRequirementCodeFilterComponent("codeFilter", e);
- }
- if (element.hasDateFilter()) {
- for (DataRequirement.DataRequirementDateFilterComponent e : element.getDateFilter())
- composeDataRequirementDataRequirementDateFilterComponent("dateFilter", e);
- }
- }
-
- protected void composeDataRequirementDataRequirementCodeFilterComponent(String name, DataRequirement.DataRequirementCodeFilterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDataRequirementDataRequirementCodeFilterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDataRequirementDataRequirementCodeFilterComponentElements(DataRequirement.DataRequirementCodeFilterComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasPathElement()) {
- composeString("path", element.getPathElement());
- }
- if (element.hasValueSet()) {
- composeType("valueSet", element.getValueSet());
- } if (element.hasValueCode()) {
- for (CodeType e : element.getValueCode())
- composeCode("valueCode", e);
- }
- if (element.hasValueCoding()) {
- for (Coding e : element.getValueCoding())
- composeCoding("valueCoding", e);
- }
- if (element.hasValueCodeableConcept()) {
- for (CodeableConcept e : element.getValueCodeableConcept())
- composeCodeableConcept("valueCodeableConcept", e);
- }
- }
-
- protected void composeDataRequirementDataRequirementDateFilterComponent(String name, DataRequirement.DataRequirementDateFilterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDataRequirementDataRequirementDateFilterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDataRequirementDataRequirementDateFilterComponentElements(DataRequirement.DataRequirementDateFilterComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasPathElement()) {
- composeString("path", element.getPathElement());
- }
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeActionDefinition(String name, ActionDefinition element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeActionDefinitionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeActionDefinitionElements(ActionDefinition element) throws IOException {
- composeElementElements(element);
- if (element.hasActionIdentifier()) {
- composeIdentifier("actionIdentifier", element.getActionIdentifier());
- }
- if (element.hasLabelElement()) {
- composeString("label", element.getLabelElement());
- }
- if (element.hasTitleElement()) {
- composeString("title", element.getTitleElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasTextEquivalentElement()) {
- composeString("textEquivalent", element.getTextEquivalentElement());
- }
- if (element.hasConcept()) {
- for (CodeableConcept e : element.getConcept())
- composeCodeableConcept("concept", e);
- }
- if (element.hasSupportingEvidence()) {
- for (Attachment e : element.getSupportingEvidence())
- composeAttachment("supportingEvidence", e);
- }
- if (element.hasDocumentation()) {
- for (Attachment e : element.getDocumentation())
- composeAttachment("documentation", e);
- }
- if (element.hasRelatedAction()) {
- composeActionDefinitionActionDefinitionRelatedActionComponent("relatedAction", element.getRelatedAction());
- }
- if (element.hasParticipantType())
- for (Enumeration e : element.getParticipantType())
- composeEnumeration("participantType", e, new ActionDefinition.ParticipantTypeEnumFactory());
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new ActionDefinition.ActionTypeEnumFactory());
- if (element.hasBehavior()) {
- for (ActionDefinition.ActionDefinitionBehaviorComponent e : element.getBehavior())
- composeActionDefinitionActionDefinitionBehaviorComponent("behavior", e);
- }
- if (element.hasResource()) {
- composeReference("resource", element.getResource());
- }
- if (element.hasCustomization()) {
- for (ActionDefinition.ActionDefinitionCustomizationComponent e : element.getCustomization())
- composeActionDefinitionActionDefinitionCustomizationComponent("customization", e);
- }
- if (element.hasAction()) {
- for (ActionDefinition e : element.getAction())
- composeActionDefinition("action", e);
- }
- }
-
- protected void composeActionDefinitionActionDefinitionRelatedActionComponent(String name, ActionDefinition.ActionDefinitionRelatedActionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeActionDefinitionActionDefinitionRelatedActionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeActionDefinitionActionDefinitionRelatedActionComponentElements(ActionDefinition.ActionDefinitionRelatedActionComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasActionIdentifier()) {
- composeIdentifier("actionIdentifier", element.getActionIdentifier());
- }
- if (element.hasRelationshipElement())
- composeEnumeration("relationship", element.getRelationshipElement(), new ActionDefinition.ActionRelationshipTypeEnumFactory());
- if (element.hasOffset()) {
- composeType("offset", element.getOffset());
- } if (element.hasAnchorElement())
- composeEnumeration("anchor", element.getAnchorElement(), new ActionDefinition.ActionRelationshipAnchorEnumFactory());
- }
-
- protected void composeActionDefinitionActionDefinitionBehaviorComponent(String name, ActionDefinition.ActionDefinitionBehaviorComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeActionDefinitionActionDefinitionBehaviorComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeActionDefinitionActionDefinitionBehaviorComponentElements(ActionDefinition.ActionDefinitionBehaviorComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasValue()) {
- composeCoding("value", element.getValue());
- }
- }
-
- protected void composeActionDefinitionActionDefinitionCustomizationComponent(String name, ActionDefinition.ActionDefinitionCustomizationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeActionDefinitionActionDefinitionCustomizationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeActionDefinitionActionDefinitionCustomizationComponentElements(ActionDefinition.ActionDefinitionCustomizationComponent element) throws IOException {
- composeElementElements(element);
- if (element.hasPathElement()) {
- composeString("path", element.getPathElement());
- }
- if (element.hasExpressionElement()) {
- composeString("expression", element.getExpressionElement());
- }
- }
-
- protected void composeParameterDefinition(String name, ParameterDefinition element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeParameterDefinitionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeParameterDefinitionElements(ParameterDefinition element) throws IOException {
- composeElementElements(element);
- if (element.hasNameElement()) {
- composeCode("name", element.getNameElement());
- }
- if (element.hasUseElement()) {
- composeCode("use", element.getUseElement());
- }
- if (element.hasMinElement()) {
- composeInteger("min", element.getMinElement());
- }
- if (element.hasMaxElement()) {
- composeString("max", element.getMaxElement());
- }
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- if (element.hasTypeElement()) {
- composeCode("type", element.getTypeElement());
- }
- if (element.hasProfile()) {
- composeReference("profile", element.getProfile());
- }
- }
-
- protected void composeDomainResourceAttributes(DomainResource element) throws IOException {
- composeResourceAttributes(element);
- }
-
- protected void composeDomainResourceElements(DomainResource element) throws IOException {
- composeResourceElements(element);
- if (element.hasText()) {
- composeNarrative("text", element.getText());
- }
- if (element.hasContained()) {
- for (Resource e : element.getContained())
- {
- xml.enter(FHIR_NS, "contained");
- composeResource(e);
- xml.exit(FHIR_NS, "contained");
- }
- }
- if (element.hasExtension())
- for (Extension e : element.getExtension())
- composeExtension("extension", e);
- if (element.hasModifierExtension()) {
- for (Extension e : element.getModifierExtension())
- composeExtension("modifierExtension", e);
- }
- }
-
- protected void composeParameters(String name, Parameters element) throws IOException {
- if (element != null) {
- composeResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeParametersElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeParametersElements(Parameters element) throws IOException {
- composeResourceElements(element);
- if (element.hasParameter()) {
- for (Parameters.ParametersParameterComponent e : element.getParameter())
- composeParametersParametersParameterComponent("parameter", e);
- }
- }
-
- protected void composeParametersParametersParameterComponent(String name, Parameters.ParametersParameterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeParametersParametersParameterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeParametersParametersParameterComponentElements(Parameters.ParametersParameterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } if (element.hasResource()) {
- xml.enter(FHIR_NS, "resource");
- composeResource(element.getResource());
- xml.exit(FHIR_NS, "resource");
- }
- if (element.hasPart()) {
- for (Parameters.ParametersParameterComponent e : element.getPart())
- composeParametersParametersParameterComponent("part", e);
- }
- }
-
- protected void composeResourceAttributes(Resource element) throws IOException {
- if (style != OutputStyle.CANONICAL)
- for (String comment : element.getFormatCommentsPre())
- xml.comment(comment, getOutputStyle() == OutputStyle.PRETTY);
- }
-
- protected void composeResourceElements(Resource element) throws IOException {
- if (element.hasIdElement()) {
- composeId("id", element.getIdElement());
- }
- if (element.hasMeta()) {
- composeMeta("meta", element.getMeta());
- }
- if (element.hasImplicitRulesElement()) {
- composeUri("implicitRules", element.getImplicitRulesElement());
- }
- if (element.hasLanguageElement()) {
- composeCode("language", element.getLanguageElement());
- }
- }
-
- protected void composeAccount(String name, Account element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAccountElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAccountElements(Account element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Account.AccountStatusEnumFactory());
- if (element.hasActivePeriod()) {
- composePeriod("activePeriod", element.getActivePeriod());
- }
- if (element.hasCurrency()) {
- composeCoding("currency", element.getCurrency());
- }
- if (element.hasBalance()) {
- composeMoney("balance", element.getBalance());
- }
- if (element.hasCoveragePeriod()) {
- composePeriod("coveragePeriod", element.getCoveragePeriod());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasOwner()) {
- composeReference("owner", element.getOwner());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- }
-
- protected void composeAllergyIntolerance(String name, AllergyIntolerance element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAllergyIntoleranceElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAllergyIntoleranceElements(AllergyIntolerance element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new AllergyIntolerance.AllergyIntoleranceStatusEnumFactory());
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new AllergyIntolerance.AllergyIntoleranceTypeEnumFactory());
- if (element.hasCategoryElement())
- composeEnumeration("category", element.getCategoryElement(), new AllergyIntolerance.AllergyIntoleranceCategoryEnumFactory());
- if (element.hasCriticalityElement())
- composeEnumeration("criticality", element.getCriticalityElement(), new AllergyIntolerance.AllergyIntoleranceCriticalityEnumFactory());
- if (element.hasSubstance()) {
- composeCodeableConcept("substance", element.getSubstance());
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasRecordedDateElement()) {
- composeDateTime("recordedDate", element.getRecordedDateElement());
- }
- if (element.hasRecorder()) {
- composeReference("recorder", element.getRecorder());
- }
- if (element.hasReporter()) {
- composeReference("reporter", element.getReporter());
- }
- if (element.hasOnsetElement()) {
- composeDateTime("onset", element.getOnsetElement());
- }
- if (element.hasLastOccurenceElement()) {
- composeDateTime("lastOccurence", element.getLastOccurenceElement());
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- if (element.hasReaction()) {
- for (AllergyIntolerance.AllergyIntoleranceReactionComponent e : element.getReaction())
- composeAllergyIntoleranceAllergyIntoleranceReactionComponent("reaction", e);
- }
- }
-
- protected void composeAllergyIntoleranceAllergyIntoleranceReactionComponent(String name, AllergyIntolerance.AllergyIntoleranceReactionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAllergyIntoleranceAllergyIntoleranceReactionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAllergyIntoleranceAllergyIntoleranceReactionComponentElements(AllergyIntolerance.AllergyIntoleranceReactionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSubstance()) {
- composeCodeableConcept("substance", element.getSubstance());
- }
- if (element.hasCertaintyElement())
- composeEnumeration("certainty", element.getCertaintyElement(), new AllergyIntolerance.AllergyIntoleranceCertaintyEnumFactory());
- if (element.hasManifestation()) {
- for (CodeableConcept e : element.getManifestation())
- composeCodeableConcept("manifestation", e);
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasOnsetElement()) {
- composeDateTime("onset", element.getOnsetElement());
- }
- if (element.hasSeverityElement())
- composeEnumeration("severity", element.getSeverityElement(), new AllergyIntolerance.AllergyIntoleranceSeverityEnumFactory());
- if (element.hasExposureRoute()) {
- composeCodeableConcept("exposureRoute", element.getExposureRoute());
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- }
-
- protected void composeAppointment(String name, Appointment element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAppointmentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAppointmentElements(Appointment element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Appointment.AppointmentStatusEnumFactory());
- if (element.hasServiceCategory()) {
- composeCodeableConcept("serviceCategory", element.getServiceCategory());
- }
- if (element.hasServiceType()) {
- for (CodeableConcept e : element.getServiceType())
- composeCodeableConcept("serviceType", e);
- }
- if (element.hasSpecialty()) {
- for (CodeableConcept e : element.getSpecialty())
- composeCodeableConcept("specialty", e);
- }
- if (element.hasAppointmentType()) {
- composeCodeableConcept("appointmentType", element.getAppointmentType());
- }
- if (element.hasReason()) {
- composeCodeableConcept("reason", element.getReason());
- }
- if (element.hasPriorityElement()) {
- composeUnsignedInt("priority", element.getPriorityElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasStartElement()) {
- composeInstant("start", element.getStartElement());
- }
- if (element.hasEndElement()) {
- composeInstant("end", element.getEndElement());
- }
- if (element.hasMinutesDurationElement()) {
- composePositiveInt("minutesDuration", element.getMinutesDurationElement());
- }
- if (element.hasSlot()) {
- for (Reference e : element.getSlot())
- composeReference("slot", e);
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasCommentElement()) {
- composeString("comment", element.getCommentElement());
- }
- if (element.hasParticipant()) {
- for (Appointment.AppointmentParticipantComponent e : element.getParticipant())
- composeAppointmentAppointmentParticipantComponent("participant", e);
- }
- }
-
- protected void composeAppointmentAppointmentParticipantComponent(String name, Appointment.AppointmentParticipantComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAppointmentAppointmentParticipantComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAppointmentAppointmentParticipantComponentElements(Appointment.AppointmentParticipantComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- for (CodeableConcept e : element.getType())
- composeCodeableConcept("type", e);
- }
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasRequiredElement())
- composeEnumeration("required", element.getRequiredElement(), new Appointment.ParticipantRequiredEnumFactory());
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Appointment.ParticipationStatusEnumFactory());
- }
-
- protected void composeAppointmentResponse(String name, AppointmentResponse element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAppointmentResponseElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAppointmentResponseElements(AppointmentResponse element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasAppointment()) {
- composeReference("appointment", element.getAppointment());
- }
- if (element.hasStartElement()) {
- composeInstant("start", element.getStartElement());
- }
- if (element.hasEndElement()) {
- composeInstant("end", element.getEndElement());
- }
- if (element.hasParticipantType()) {
- for (CodeableConcept e : element.getParticipantType())
- composeCodeableConcept("participantType", e);
- }
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasParticipantStatusElement()) {
- composeCode("participantStatus", element.getParticipantStatusElement());
- }
- if (element.hasCommentElement()) {
- composeString("comment", element.getCommentElement());
- }
- }
-
- protected void composeAuditEvent(String name, AuditEvent element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAuditEventElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAuditEventElements(AuditEvent element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasSubtype()) {
- for (Coding e : element.getSubtype())
- composeCoding("subtype", e);
- }
- if (element.hasActionElement())
- composeEnumeration("action", element.getActionElement(), new AuditEvent.AuditEventActionEnumFactory());
- if (element.hasRecordedElement()) {
- composeInstant("recorded", element.getRecordedElement());
- }
- if (element.hasOutcomeElement())
- composeEnumeration("outcome", element.getOutcomeElement(), new AuditEvent.AuditEventOutcomeEnumFactory());
- if (element.hasOutcomeDescElement()) {
- composeString("outcomeDesc", element.getOutcomeDescElement());
- }
- if (element.hasPurposeOfEvent()) {
- for (Coding e : element.getPurposeOfEvent())
- composeCoding("purposeOfEvent", e);
- }
- if (element.hasAgent()) {
- for (AuditEvent.AuditEventAgentComponent e : element.getAgent())
- composeAuditEventAuditEventAgentComponent("agent", e);
- }
- if (element.hasSource()) {
- composeAuditEventAuditEventSourceComponent("source", element.getSource());
- }
- if (element.hasEntity()) {
- for (AuditEvent.AuditEventEntityComponent e : element.getEntity())
- composeAuditEventAuditEventEntityComponent("entity", e);
- }
- }
-
- protected void composeAuditEventAuditEventAgentComponent(String name, AuditEvent.AuditEventAgentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAuditEventAuditEventAgentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAuditEventAuditEventAgentComponentElements(AuditEvent.AuditEventAgentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRole()) {
- for (CodeableConcept e : element.getRole())
- composeCodeableConcept("role", e);
- }
- if (element.hasReference()) {
- composeReference("reference", element.getReference());
- }
- if (element.hasUserId()) {
- composeIdentifier("userId", element.getUserId());
- }
- if (element.hasAltIdElement()) {
- composeString("altId", element.getAltIdElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasRequestorElement()) {
- composeBoolean("requestor", element.getRequestorElement());
- }
- if (element.hasLocation()) {
- composeReference("location", element.getLocation());
- }
- if (element.hasPolicy()) {
- for (UriType e : element.getPolicy())
- composeUri("policy", e);
- }
- if (element.hasMedia()) {
- composeCoding("media", element.getMedia());
- }
- if (element.hasNetwork()) {
- composeAuditEventAuditEventAgentNetworkComponent("network", element.getNetwork());
- }
- if (element.hasPurposeOfUse()) {
- for (Coding e : element.getPurposeOfUse())
- composeCoding("purposeOfUse", e);
- }
- }
-
- protected void composeAuditEventAuditEventAgentNetworkComponent(String name, AuditEvent.AuditEventAgentNetworkComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAuditEventAuditEventAgentNetworkComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAuditEventAuditEventAgentNetworkComponentElements(AuditEvent.AuditEventAgentNetworkComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasAddressElement()) {
- composeString("address", element.getAddressElement());
- }
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new AuditEvent.AuditEventParticipantNetworkTypeEnumFactory());
- }
-
- protected void composeAuditEventAuditEventSourceComponent(String name, AuditEvent.AuditEventSourceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAuditEventAuditEventSourceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAuditEventAuditEventSourceComponentElements(AuditEvent.AuditEventSourceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSiteElement()) {
- composeString("site", element.getSiteElement());
- }
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasType()) {
- for (Coding e : element.getType())
- composeCoding("type", e);
- }
- }
-
- protected void composeAuditEventAuditEventEntityComponent(String name, AuditEvent.AuditEventEntityComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAuditEventAuditEventEntityComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAuditEventAuditEventEntityComponentElements(AuditEvent.AuditEventEntityComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasReference()) {
- composeReference("reference", element.getReference());
- }
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasRole()) {
- composeCoding("role", element.getRole());
- }
- if (element.hasLifecycle()) {
- composeCoding("lifecycle", element.getLifecycle());
- }
- if (element.hasSecurityLabel()) {
- for (Coding e : element.getSecurityLabel())
- composeCoding("securityLabel", e);
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasQueryElement()) {
- composeBase64Binary("query", element.getQueryElement());
- }
- if (element.hasDetail()) {
- for (AuditEvent.AuditEventEntityDetailComponent e : element.getDetail())
- composeAuditEventAuditEventEntityDetailComponent("detail", e);
- }
- }
-
- protected void composeAuditEventAuditEventEntityDetailComponent(String name, AuditEvent.AuditEventEntityDetailComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeAuditEventAuditEventEntityDetailComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeAuditEventAuditEventEntityDetailComponentElements(AuditEvent.AuditEventEntityDetailComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement()) {
- composeString("type", element.getTypeElement());
- }
- if (element.hasValueElement()) {
- composeBase64Binary("value", element.getValueElement());
- }
- }
-
- protected void composeBasic(String name, Basic element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeBasicElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeBasicElements(Basic element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasCreatedElement()) {
- composeDate("created", element.getCreatedElement());
- }
- if (element.hasAuthor()) {
- composeReference("author", element.getAuthor());
- }
- }
-
- protected void composeBinary(String name, Binary element) throws IOException {
- if (element != null) {
- composeResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeBinaryElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeBinaryElements(Binary element) throws IOException {
- composeResourceElements(element);
- if (element.hasContentTypeElement()) {
- composeCode("contentType", element.getContentTypeElement());
- }
- if (element.hasContentElement()) {
- composeBase64Binary("content", element.getContentElement());
- }
- }
-
- protected void composeBodySite(String name, BodySite element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeBodySiteElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeBodySiteElements(BodySite element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasModifier()) {
- for (CodeableConcept e : element.getModifier())
- composeCodeableConcept("modifier", e);
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasImage()) {
- for (Attachment e : element.getImage())
- composeAttachment("image", e);
- }
- }
-
- protected void composeBundle(String name, Bundle element) throws IOException {
- if (element != null) {
- composeResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeBundleElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeBundleElements(Bundle element) throws IOException {
- composeResourceElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Bundle.BundleTypeEnumFactory());
- if (element.hasTotalElement()) {
- composeUnsignedInt("total", element.getTotalElement());
- }
- if (element.hasLink()) {
- for (Bundle.BundleLinkComponent e : element.getLink())
- composeBundleBundleLinkComponent("link", e);
- }
- if (element.hasEntry()) {
- for (Bundle.BundleEntryComponent e : element.getEntry())
- composeBundleBundleEntryComponent("entry", e);
- }
- if (element.hasSignature()) {
- composeSignature("signature", element.getSignature());
- }
- }
-
- protected void composeBundleBundleLinkComponent(String name, Bundle.BundleLinkComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeBundleBundleLinkComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeBundleBundleLinkComponentElements(Bundle.BundleLinkComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRelationElement()) {
- composeString("relation", element.getRelationElement());
- }
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- }
-
- protected void composeBundleBundleEntryComponent(String name, Bundle.BundleEntryComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeBundleBundleEntryComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeBundleBundleEntryComponentElements(Bundle.BundleEntryComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLink()) {
- for (Bundle.BundleLinkComponent e : element.getLink())
- composeBundleBundleLinkComponent("link", e);
- }
- if (element.hasFullUrlElement()) {
- composeUri("fullUrl", element.getFullUrlElement());
- }
- if (element.hasResource()) {
- xml.enter(FHIR_NS, "resource");
- composeResource(element.getResource());
- xml.exit(FHIR_NS, "resource");
- }
- if (element.hasSearch()) {
- composeBundleBundleEntrySearchComponent("search", element.getSearch());
- }
- if (element.hasRequest()) {
- composeBundleBundleEntryRequestComponent("request", element.getRequest());
- }
- if (element.hasResponse()) {
- composeBundleBundleEntryResponseComponent("response", element.getResponse());
- }
- }
-
- protected void composeBundleBundleEntrySearchComponent(String name, Bundle.BundleEntrySearchComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeBundleBundleEntrySearchComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeBundleBundleEntrySearchComponentElements(Bundle.BundleEntrySearchComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasModeElement())
- composeEnumeration("mode", element.getModeElement(), new Bundle.SearchEntryModeEnumFactory());
- if (element.hasScoreElement()) {
- composeDecimal("score", element.getScoreElement());
- }
- }
-
- protected void composeBundleBundleEntryRequestComponent(String name, Bundle.BundleEntryRequestComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeBundleBundleEntryRequestComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeBundleBundleEntryRequestComponentElements(Bundle.BundleEntryRequestComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasMethodElement())
- composeEnumeration("method", element.getMethodElement(), new Bundle.HTTPVerbEnumFactory());
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasIfNoneMatchElement()) {
- composeString("ifNoneMatch", element.getIfNoneMatchElement());
- }
- if (element.hasIfModifiedSinceElement()) {
- composeInstant("ifModifiedSince", element.getIfModifiedSinceElement());
- }
- if (element.hasIfMatchElement()) {
- composeString("ifMatch", element.getIfMatchElement());
- }
- if (element.hasIfNoneExistElement()) {
- composeString("ifNoneExist", element.getIfNoneExistElement());
- }
- }
-
- protected void composeBundleBundleEntryResponseComponent(String name, Bundle.BundleEntryResponseComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeBundleBundleEntryResponseComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeBundleBundleEntryResponseComponentElements(Bundle.BundleEntryResponseComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStatusElement()) {
- composeString("status", element.getStatusElement());
- }
- if (element.hasLocationElement()) {
- composeUri("location", element.getLocationElement());
- }
- if (element.hasEtagElement()) {
- composeString("etag", element.getEtagElement());
- }
- if (element.hasLastModifiedElement()) {
- composeInstant("lastModified", element.getLastModifiedElement());
- }
- }
-
- protected void composeCarePlan(String name, CarePlan element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCarePlanElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCarePlanElements(CarePlan element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new CarePlan.CarePlanStatusEnumFactory());
- if (element.hasContext()) {
- composeReference("context", element.getContext());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasAuthor()) {
- for (Reference e : element.getAuthor())
- composeReference("author", e);
- }
- if (element.hasModifiedElement()) {
- composeDateTime("modified", element.getModifiedElement());
- }
- if (element.hasCategory()) {
- for (CodeableConcept e : element.getCategory())
- composeCodeableConcept("category", e);
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasAddresses()) {
- for (Reference e : element.getAddresses())
- composeReference("addresses", e);
- }
- if (element.hasSupport()) {
- for (Reference e : element.getSupport())
- composeReference("support", e);
- }
- if (element.hasRelatedPlan()) {
- for (CarePlan.CarePlanRelatedPlanComponent e : element.getRelatedPlan())
- composeCarePlanCarePlanRelatedPlanComponent("relatedPlan", e);
- }
- if (element.hasCareTeam()) {
- composeReference("careTeam", element.getCareTeam());
- }
- if (element.hasGoal()) {
- for (Reference e : element.getGoal())
- composeReference("goal", e);
- }
- if (element.hasActivity()) {
- for (CarePlan.CarePlanActivityComponent e : element.getActivity())
- composeCarePlanCarePlanActivityComponent("activity", e);
- }
- if (element.hasNote()) {
- composeAnnotation("note", element.getNote());
- }
- }
-
- protected void composeCarePlanCarePlanRelatedPlanComponent(String name, CarePlan.CarePlanRelatedPlanComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCarePlanCarePlanRelatedPlanComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCarePlanCarePlanRelatedPlanComponentElements(CarePlan.CarePlanRelatedPlanComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeElement())
- composeEnumeration("code", element.getCodeElement(), new CarePlan.CarePlanRelationshipEnumFactory());
- if (element.hasPlan()) {
- composeReference("plan", element.getPlan());
- }
- }
-
- protected void composeCarePlanCarePlanActivityComponent(String name, CarePlan.CarePlanActivityComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCarePlanCarePlanActivityComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCarePlanCarePlanActivityComponentElements(CarePlan.CarePlanActivityComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasActionResulting()) {
- for (Reference e : element.getActionResulting())
- composeReference("actionResulting", e);
- }
- if (element.hasProgress()) {
- for (Annotation e : element.getProgress())
- composeAnnotation("progress", e);
- }
- if (element.hasReference()) {
- composeReference("reference", element.getReference());
- }
- if (element.hasDetail()) {
- composeCarePlanCarePlanActivityDetailComponent("detail", element.getDetail());
- }
- }
-
- protected void composeCarePlanCarePlanActivityDetailComponent(String name, CarePlan.CarePlanActivityDetailComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCarePlanCarePlanActivityDetailComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCarePlanCarePlanActivityDetailComponentElements(CarePlan.CarePlanActivityDetailComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCategory()) {
- composeCodeableConcept("category", element.getCategory());
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasReasonCode()) {
- for (CodeableConcept e : element.getReasonCode())
- composeCodeableConcept("reasonCode", e);
- }
- if (element.hasReasonReference()) {
- for (Reference e : element.getReasonReference())
- composeReference("reasonReference", e);
- }
- if (element.hasGoal()) {
- for (Reference e : element.getGoal())
- composeReference("goal", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new CarePlan.CarePlanActivityStatusEnumFactory());
- if (element.hasStatusReason()) {
- composeCodeableConcept("statusReason", element.getStatusReason());
- }
- if (element.hasProhibitedElement()) {
- composeBoolean("prohibited", element.getProhibitedElement());
- }
- if (element.hasScheduled()) {
- composeType("scheduled", element.getScheduled());
- } if (element.hasLocation()) {
- composeReference("location", element.getLocation());
- }
- if (element.hasPerformer()) {
- for (Reference e : element.getPerformer())
- composeReference("performer", e);
- }
- if (element.hasProduct()) {
- composeType("product", element.getProduct());
- } if (element.hasDailyAmount()) {
- composeSimpleQuantity("dailyAmount", element.getDailyAmount());
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- }
-
- protected void composeCareTeam(String name, CareTeam element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCareTeamElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCareTeamElements(CareTeam element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatus()) {
- composeCodeableConcept("status", element.getStatus());
- }
- if (element.hasType()) {
- for (CodeableConcept e : element.getType())
- composeCodeableConcept("type", e);
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasParticipant()) {
- for (CareTeam.CareTeamParticipantComponent e : element.getParticipant())
- composeCareTeamCareTeamParticipantComponent("participant", e);
- }
- if (element.hasManagingOrganization()) {
- composeReference("managingOrganization", element.getManagingOrganization());
- }
- }
-
- protected void composeCareTeamCareTeamParticipantComponent(String name, CareTeam.CareTeamParticipantComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCareTeamCareTeamParticipantComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCareTeamCareTeamParticipantComponentElements(CareTeam.CareTeamParticipantComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRole()) {
- composeCodeableConcept("role", element.getRole());
- }
- if (element.hasMember()) {
- composeReference("member", element.getMember());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composeClaim(String name, Claim element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimElements(Claim element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Claim.ClaimTypeEnumFactory());
- if (element.hasSubType()) {
- for (Coding e : element.getSubType())
- composeCoding("subType", e);
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasRuleset()) {
- composeCoding("ruleset", element.getRuleset());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasBillablePeriod()) {
- composePeriod("billablePeriod", element.getBillablePeriod());
- }
- if (element.hasTarget()) {
- composeType("target", element.getTarget());
- } if (element.hasProvider()) {
- composeType("provider", element.getProvider());
- } if (element.hasOrganization()) {
- composeType("organization", element.getOrganization());
- } if (element.hasUseElement())
- composeEnumeration("use", element.getUseElement(), new Claim.UseEnumFactory());
- if (element.hasPriority()) {
- composeCoding("priority", element.getPriority());
- }
- if (element.hasFundsReserve()) {
- composeCoding("fundsReserve", element.getFundsReserve());
- }
- if (element.hasEnterer()) {
- composeType("enterer", element.getEnterer());
- } if (element.hasFacility()) {
- composeType("facility", element.getFacility());
- } if (element.hasRelated()) {
- for (Claim.RelatedClaimComponent e : element.getRelated())
- composeClaimRelatedClaimComponent("related", e);
- }
- if (element.hasPrescription()) {
- composeType("prescription", element.getPrescription());
- } if (element.hasOriginalPrescription()) {
- composeType("originalPrescription", element.getOriginalPrescription());
- } if (element.hasPayee()) {
- composeClaimPayeeComponent("payee", element.getPayee());
- }
- if (element.hasReferral()) {
- composeType("referral", element.getReferral());
- } if (element.hasInformation()) {
- for (Claim.InformationComponent e : element.getInformation())
- composeClaimInformationComponent("information", e);
- }
- if (element.hasDiagnosis()) {
- for (Claim.DiagnosisComponent e : element.getDiagnosis())
- composeClaimDiagnosisComponent("diagnosis", e);
- }
- if (element.hasProcedure()) {
- for (Claim.ProcedureComponent e : element.getProcedure())
- composeClaimProcedureComponent("procedure", e);
- }
- if (element.hasPatient()) {
- composeType("patient", element.getPatient());
- } if (element.hasCoverage()) {
- for (Claim.CoverageComponent e : element.getCoverage())
- composeClaimCoverageComponent("coverage", e);
- }
- if (element.hasItem()) {
- for (Claim.ItemComponent e : element.getItem())
- composeClaimItemComponent("item", e);
- }
- if (element.hasTotal()) {
- composeMoney("total", element.getTotal());
- }
- }
-
- protected void composeClaimRelatedClaimComponent(String name, Claim.RelatedClaimComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimRelatedClaimComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimRelatedClaimComponentElements(Claim.RelatedClaimComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasClaim()) {
- composeType("claim", element.getClaim());
- } if (element.hasRelationship()) {
- composeCoding("relationship", element.getRelationship());
- }
- if (element.hasReference()) {
- composeIdentifier("reference", element.getReference());
- }
- }
-
- protected void composeClaimPayeeComponent(String name, Claim.PayeeComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimPayeeComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimPayeeComponentElements(Claim.PayeeComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasResourceType()) {
- composeCoding("resourceType", element.getResourceType());
- }
- if (element.hasParty()) {
- composeType("party", element.getParty());
- } }
-
- protected void composeClaimInformationComponent(String name, Claim.InformationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimInformationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimInformationComponentElements(Claim.InformationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCategory()) {
- composeCoding("category", element.getCategory());
- }
- if (element.hasCode()) {
- composeCoding("code", element.getCode());
- }
- if (element.hasReason()) {
- composeCoding("reason", element.getReason());
- }
- if (element.hasTiming()) {
- composeType("timing", element.getTiming());
- } if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeClaimDiagnosisComponent(String name, Claim.DiagnosisComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimDiagnosisComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimDiagnosisComponentElements(Claim.DiagnosisComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasDiagnosis()) {
- composeCoding("diagnosis", element.getDiagnosis());
- }
- }
-
- protected void composeClaimProcedureComponent(String name, Claim.ProcedureComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimProcedureComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimProcedureComponentElements(Claim.ProcedureComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasProcedure()) {
- composeType("procedure", element.getProcedure());
- } }
-
- protected void composeClaimCoverageComponent(String name, Claim.CoverageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimCoverageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimCoverageComponentElements(Claim.CoverageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasFocalElement()) {
- composeBoolean("focal", element.getFocalElement());
- }
- if (element.hasCoverage()) {
- composeType("coverage", element.getCoverage());
- } if (element.hasPreAuthRef()) {
- for (StringType e : element.getPreAuthRef())
- composeString("preAuthRef", e);
- }
- if (element.hasClaimResponse()) {
- composeReference("claimResponse", element.getClaimResponse());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- }
-
- protected void composeClaimItemComponent(String name, Claim.ItemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimItemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimItemComponentElements(Claim.ItemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasCareTeam()) {
- for (Claim.CareTeamComponent e : element.getCareTeam())
- composeClaimCareTeamComponent("careTeam", e);
- }
- if (element.hasDiagnosisLinkId()) {
- for (PositiveIntType e : element.getDiagnosisLinkId())
- composePositiveInt("diagnosisLinkId", e);
- }
- if (element.hasService()) {
- composeCoding("service", element.getService());
- }
- if (element.hasServiceModifier()) {
- for (Coding e : element.getServiceModifier())
- composeCoding("serviceModifier", e);
- }
- if (element.hasModifier()) {
- for (Coding e : element.getModifier())
- composeCoding("modifier", e);
- }
- if (element.hasProgramCode()) {
- for (Coding e : element.getProgramCode())
- composeCoding("programCode", e);
- }
- if (element.hasServiced()) {
- composeType("serviced", element.getServiced());
- } if (element.hasServiceLocation()) {
- composeType("serviceLocation", element.getServiceLocation());
- } if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasUnitPrice()) {
- composeMoney("unitPrice", element.getUnitPrice());
- }
- if (element.hasFactorElement()) {
- composeDecimal("factor", element.getFactorElement());
- }
- if (element.hasPointsElement()) {
- composeDecimal("points", element.getPointsElement());
- }
- if (element.hasNet()) {
- composeMoney("net", element.getNet());
- }
- if (element.hasUdi()) {
- for (Reference e : element.getUdi())
- composeReference("udi", e);
- }
- if (element.hasBodySite()) {
- composeCoding("bodySite", element.getBodySite());
- }
- if (element.hasSubSite()) {
- for (Coding e : element.getSubSite())
- composeCoding("subSite", e);
- }
- if (element.hasDetail()) {
- for (Claim.DetailComponent e : element.getDetail())
- composeClaimDetailComponent("detail", e);
- }
- if (element.hasProsthesis()) {
- composeClaimProsthesisComponent("prosthesis", element.getProsthesis());
- }
- }
-
- protected void composeClaimCareTeamComponent(String name, Claim.CareTeamComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimCareTeamComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimCareTeamComponentElements(Claim.CareTeamComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasProvider()) {
- composeType("provider", element.getProvider());
- } if (element.hasResponsibleElement()) {
- composeBoolean("responsible", element.getResponsibleElement());
- }
- if (element.hasRole()) {
- composeCoding("role", element.getRole());
- }
- if (element.hasQualification()) {
- composeCoding("qualification", element.getQualification());
- }
- }
-
- protected void composeClaimDetailComponent(String name, Claim.DetailComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimDetailComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimDetailComponentElements(Claim.DetailComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasService()) {
- composeCoding("service", element.getService());
- }
- if (element.hasProgramCode()) {
- for (Coding e : element.getProgramCode())
- composeCoding("programCode", e);
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasUnitPrice()) {
- composeMoney("unitPrice", element.getUnitPrice());
- }
- if (element.hasFactorElement()) {
- composeDecimal("factor", element.getFactorElement());
- }
- if (element.hasPointsElement()) {
- composeDecimal("points", element.getPointsElement());
- }
- if (element.hasNet()) {
- composeMoney("net", element.getNet());
- }
- if (element.hasUdi()) {
- for (Reference e : element.getUdi())
- composeReference("udi", e);
- }
- if (element.hasSubDetail()) {
- for (Claim.SubDetailComponent e : element.getSubDetail())
- composeClaimSubDetailComponent("subDetail", e);
- }
- }
-
- protected void composeClaimSubDetailComponent(String name, Claim.SubDetailComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimSubDetailComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimSubDetailComponentElements(Claim.SubDetailComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasService()) {
- composeCoding("service", element.getService());
- }
- if (element.hasProgramCode()) {
- for (Coding e : element.getProgramCode())
- composeCoding("programCode", e);
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasUnitPrice()) {
- composeMoney("unitPrice", element.getUnitPrice());
- }
- if (element.hasFactorElement()) {
- composeDecimal("factor", element.getFactorElement());
- }
- if (element.hasPointsElement()) {
- composeDecimal("points", element.getPointsElement());
- }
- if (element.hasNet()) {
- composeMoney("net", element.getNet());
- }
- if (element.hasUdi()) {
- for (Reference e : element.getUdi())
- composeReference("udi", e);
- }
- }
-
- protected void composeClaimProsthesisComponent(String name, Claim.ProsthesisComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimProsthesisComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimProsthesisComponentElements(Claim.ProsthesisComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasInitialElement()) {
- composeBoolean("initial", element.getInitialElement());
- }
- if (element.hasPriorDateElement()) {
- composeDate("priorDate", element.getPriorDateElement());
- }
- if (element.hasPriorMaterial()) {
- composeCoding("priorMaterial", element.getPriorMaterial());
- }
- }
-
- protected void composeClaimResponse(String name, ClaimResponse element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimResponseElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimResponseElements(ClaimResponse element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasRequest()) {
- composeType("request", element.getRequest());
- } if (element.hasRuleset()) {
- composeCoding("ruleset", element.getRuleset());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasOrganization()) {
- composeType("organization", element.getOrganization());
- } if (element.hasRequestProvider()) {
- composeType("requestProvider", element.getRequestProvider());
- } if (element.hasRequestOrganization()) {
- composeType("requestOrganization", element.getRequestOrganization());
- } if (element.hasOutcomeElement())
- composeEnumeration("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory());
- if (element.hasDispositionElement()) {
- composeString("disposition", element.getDispositionElement());
- }
- if (element.hasPayeeType()) {
- composeCoding("payeeType", element.getPayeeType());
- }
- if (element.hasItem()) {
- for (ClaimResponse.ItemComponent e : element.getItem())
- composeClaimResponseItemComponent("item", e);
- }
- if (element.hasAddItem()) {
- for (ClaimResponse.AddedItemComponent e : element.getAddItem())
- composeClaimResponseAddedItemComponent("addItem", e);
- }
- if (element.hasError()) {
- for (ClaimResponse.ErrorComponent e : element.getError())
- composeClaimResponseErrorComponent("error", e);
- }
- if (element.hasTotalCost()) {
- composeMoney("totalCost", element.getTotalCost());
- }
- if (element.hasUnallocDeductable()) {
- composeMoney("unallocDeductable", element.getUnallocDeductable());
- }
- if (element.hasTotalBenefit()) {
- composeMoney("totalBenefit", element.getTotalBenefit());
- }
- if (element.hasPaymentAdjustment()) {
- composeMoney("paymentAdjustment", element.getPaymentAdjustment());
- }
- if (element.hasPaymentAdjustmentReason()) {
- composeCoding("paymentAdjustmentReason", element.getPaymentAdjustmentReason());
- }
- if (element.hasPaymentDateElement()) {
- composeDate("paymentDate", element.getPaymentDateElement());
- }
- if (element.hasPaymentAmount()) {
- composeMoney("paymentAmount", element.getPaymentAmount());
- }
- if (element.hasPaymentRef()) {
- composeIdentifier("paymentRef", element.getPaymentRef());
- }
- if (element.hasReserved()) {
- composeCoding("reserved", element.getReserved());
- }
- if (element.hasForm()) {
- composeCoding("form", element.getForm());
- }
- if (element.hasNote()) {
- for (ClaimResponse.NoteComponent e : element.getNote())
- composeClaimResponseNoteComponent("note", e);
- }
- if (element.hasCoverage()) {
- for (ClaimResponse.CoverageComponent e : element.getCoverage())
- composeClaimResponseCoverageComponent("coverage", e);
- }
- }
-
- protected void composeClaimResponseItemComponent(String name, ClaimResponse.ItemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimResponseItemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimResponseItemComponentElements(ClaimResponse.ItemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceLinkIdElement()) {
- composePositiveInt("sequenceLinkId", element.getSequenceLinkIdElement());
- }
- if (element.hasNoteNumber()) {
- for (PositiveIntType e : element.getNoteNumber())
- composePositiveInt("noteNumber", e);
- }
- if (element.hasAdjudication()) {
- for (ClaimResponse.AdjudicationComponent e : element.getAdjudication())
- composeClaimResponseAdjudicationComponent("adjudication", e);
- }
- if (element.hasDetail()) {
- for (ClaimResponse.ItemDetailComponent e : element.getDetail())
- composeClaimResponseItemDetailComponent("detail", e);
- }
- }
-
- protected void composeClaimResponseAdjudicationComponent(String name, ClaimResponse.AdjudicationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimResponseAdjudicationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimResponseAdjudicationComponentElements(ClaimResponse.AdjudicationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCategory()) {
- composeCoding("category", element.getCategory());
- }
- if (element.hasReason()) {
- composeCoding("reason", element.getReason());
- }
- if (element.hasAmount()) {
- composeMoney("amount", element.getAmount());
- }
- if (element.hasValueElement()) {
- composeDecimal("value", element.getValueElement());
- }
- }
-
- protected void composeClaimResponseItemDetailComponent(String name, ClaimResponse.ItemDetailComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimResponseItemDetailComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimResponseItemDetailComponentElements(ClaimResponse.ItemDetailComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceLinkIdElement()) {
- composePositiveInt("sequenceLinkId", element.getSequenceLinkIdElement());
- }
- if (element.hasAdjudication()) {
- for (ClaimResponse.AdjudicationComponent e : element.getAdjudication())
- composeClaimResponseAdjudicationComponent("adjudication", e);
- }
- if (element.hasSubDetail()) {
- for (ClaimResponse.SubDetailComponent e : element.getSubDetail())
- composeClaimResponseSubDetailComponent("subDetail", e);
- }
- }
-
- protected void composeClaimResponseSubDetailComponent(String name, ClaimResponse.SubDetailComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimResponseSubDetailComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimResponseSubDetailComponentElements(ClaimResponse.SubDetailComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceLinkIdElement()) {
- composePositiveInt("sequenceLinkId", element.getSequenceLinkIdElement());
- }
- if (element.hasAdjudication()) {
- for (ClaimResponse.AdjudicationComponent e : element.getAdjudication())
- composeClaimResponseAdjudicationComponent("adjudication", e);
- }
- }
-
- protected void composeClaimResponseAddedItemComponent(String name, ClaimResponse.AddedItemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimResponseAddedItemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimResponseAddedItemComponentElements(ClaimResponse.AddedItemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceLinkId()) {
- for (PositiveIntType e : element.getSequenceLinkId())
- composePositiveInt("sequenceLinkId", e);
- }
- if (element.hasService()) {
- composeCoding("service", element.getService());
- }
- if (element.hasFee()) {
- composeMoney("fee", element.getFee());
- }
- if (element.hasNoteNumberLinkId()) {
- for (PositiveIntType e : element.getNoteNumberLinkId())
- composePositiveInt("noteNumberLinkId", e);
- }
- if (element.hasAdjudication()) {
- for (ClaimResponse.AdjudicationComponent e : element.getAdjudication())
- composeClaimResponseAdjudicationComponent("adjudication", e);
- }
- if (element.hasDetail()) {
- for (ClaimResponse.AddedItemsDetailComponent e : element.getDetail())
- composeClaimResponseAddedItemsDetailComponent("detail", e);
- }
- }
-
- protected void composeClaimResponseAddedItemsDetailComponent(String name, ClaimResponse.AddedItemsDetailComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimResponseAddedItemsDetailComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimResponseAddedItemsDetailComponentElements(ClaimResponse.AddedItemsDetailComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasService()) {
- composeCoding("service", element.getService());
- }
- if (element.hasFee()) {
- composeMoney("fee", element.getFee());
- }
- if (element.hasAdjudication()) {
- for (ClaimResponse.AdjudicationComponent e : element.getAdjudication())
- composeClaimResponseAdjudicationComponent("adjudication", e);
- }
- }
-
- protected void composeClaimResponseErrorComponent(String name, ClaimResponse.ErrorComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimResponseErrorComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimResponseErrorComponentElements(ClaimResponse.ErrorComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceLinkIdElement()) {
- composePositiveInt("sequenceLinkId", element.getSequenceLinkIdElement());
- }
- if (element.hasDetailSequenceLinkIdElement()) {
- composePositiveInt("detailSequenceLinkId", element.getDetailSequenceLinkIdElement());
- }
- if (element.hasSubdetailSequenceLinkIdElement()) {
- composePositiveInt("subdetailSequenceLinkId", element.getSubdetailSequenceLinkIdElement());
- }
- if (element.hasCode()) {
- composeCoding("code", element.getCode());
- }
- }
-
- protected void composeClaimResponseNoteComponent(String name, ClaimResponse.NoteComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimResponseNoteComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimResponseNoteComponentElements(ClaimResponse.NoteComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNumberElement()) {
- composePositiveInt("number", element.getNumberElement());
- }
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- }
-
- protected void composeClaimResponseCoverageComponent(String name, ClaimResponse.CoverageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClaimResponseCoverageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClaimResponseCoverageComponentElements(ClaimResponse.CoverageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasFocalElement()) {
- composeBoolean("focal", element.getFocalElement());
- }
- if (element.hasCoverage()) {
- composeType("coverage", element.getCoverage());
- } if (element.hasBusinessArrangementElement()) {
- composeString("businessArrangement", element.getBusinessArrangementElement());
- }
- if (element.hasPreAuthRef()) {
- for (StringType e : element.getPreAuthRef())
- composeString("preAuthRef", e);
- }
- if (element.hasClaimResponse()) {
- composeReference("claimResponse", element.getClaimResponse());
- }
- }
-
- protected void composeClinicalImpression(String name, ClinicalImpression element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClinicalImpressionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClinicalImpressionElements(ClinicalImpression element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasAssessor()) {
- composeReference("assessor", element.getAssessor());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new ClinicalImpression.ClinicalImpressionStatusEnumFactory());
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasPrevious()) {
- composeReference("previous", element.getPrevious());
- }
- if (element.hasProblem()) {
- for (Reference e : element.getProblem())
- composeReference("problem", e);
- }
- if (element.hasTrigger()) {
- composeType("trigger", element.getTrigger());
- } if (element.hasInvestigations()) {
- for (ClinicalImpression.ClinicalImpressionInvestigationsComponent e : element.getInvestigations())
- composeClinicalImpressionClinicalImpressionInvestigationsComponent("investigations", e);
- }
- if (element.hasProtocolElement()) {
- composeUri("protocol", element.getProtocolElement());
- }
- if (element.hasSummaryElement()) {
- composeString("summary", element.getSummaryElement());
- }
- if (element.hasFinding()) {
- for (ClinicalImpression.ClinicalImpressionFindingComponent e : element.getFinding())
- composeClinicalImpressionClinicalImpressionFindingComponent("finding", e);
- }
- if (element.hasResolved()) {
- for (CodeableConcept e : element.getResolved())
- composeCodeableConcept("resolved", e);
- }
- if (element.hasRuledOut()) {
- for (ClinicalImpression.ClinicalImpressionRuledOutComponent e : element.getRuledOut())
- composeClinicalImpressionClinicalImpressionRuledOutComponent("ruledOut", e);
- }
- if (element.hasPrognosisElement()) {
- composeString("prognosis", element.getPrognosisElement());
- }
- if (element.hasPlan()) {
- for (Reference e : element.getPlan())
- composeReference("plan", e);
- }
- if (element.hasAction()) {
- for (Reference e : element.getAction())
- composeReference("action", e);
- }
- }
-
- protected void composeClinicalImpressionClinicalImpressionInvestigationsComponent(String name, ClinicalImpression.ClinicalImpressionInvestigationsComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClinicalImpressionClinicalImpressionInvestigationsComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClinicalImpressionClinicalImpressionInvestigationsComponentElements(ClinicalImpression.ClinicalImpressionInvestigationsComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasItem()) {
- for (Reference e : element.getItem())
- composeReference("item", e);
- }
- }
-
- protected void composeClinicalImpressionClinicalImpressionFindingComponent(String name, ClinicalImpression.ClinicalImpressionFindingComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClinicalImpressionClinicalImpressionFindingComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClinicalImpressionClinicalImpressionFindingComponentElements(ClinicalImpression.ClinicalImpressionFindingComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasItem()) {
- composeCodeableConcept("item", element.getItem());
- }
- if (element.hasCauseElement()) {
- composeString("cause", element.getCauseElement());
- }
- }
-
- protected void composeClinicalImpressionClinicalImpressionRuledOutComponent(String name, ClinicalImpression.ClinicalImpressionRuledOutComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeClinicalImpressionClinicalImpressionRuledOutComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeClinicalImpressionClinicalImpressionRuledOutComponentElements(ClinicalImpression.ClinicalImpressionRuledOutComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasItem()) {
- composeCodeableConcept("item", element.getItem());
- }
- if (element.hasReasonElement()) {
- composeString("reason", element.getReasonElement());
- }
- }
-
- protected void composeCodeSystem(String name, CodeSystem element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCodeSystemElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCodeSystemElements(CodeSystem element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (CodeSystem.CodeSystemContactComponent e : element.getContact())
- composeCodeSystemCodeSystemContactComponent("contact", e);
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasRequirementsElement()) {
- composeString("requirements", element.getRequirementsElement());
- }
- if (element.hasCopyrightElement()) {
- composeString("copyright", element.getCopyrightElement());
- }
- if (element.hasCaseSensitiveElement()) {
- composeBoolean("caseSensitive", element.getCaseSensitiveElement());
- }
- if (element.hasValueSetElement()) {
- composeUri("valueSet", element.getValueSetElement());
- }
- if (element.hasCompositionalElement()) {
- composeBoolean("compositional", element.getCompositionalElement());
- }
- if (element.hasVersionNeededElement()) {
- composeBoolean("versionNeeded", element.getVersionNeededElement());
- }
- if (element.hasContentElement())
- composeEnumeration("content", element.getContentElement(), new CodeSystem.CodeSystemContentModeEnumFactory());
- if (element.hasCountElement()) {
- composeUnsignedInt("count", element.getCountElement());
- }
- if (element.hasFilter()) {
- for (CodeSystem.CodeSystemFilterComponent e : element.getFilter())
- composeCodeSystemCodeSystemFilterComponent("filter", e);
- }
- if (element.hasProperty()) {
- for (CodeSystem.CodeSystemPropertyComponent e : element.getProperty())
- composeCodeSystemCodeSystemPropertyComponent("property", e);
- }
- if (element.hasConcept()) {
- for (CodeSystem.ConceptDefinitionComponent e : element.getConcept())
- composeCodeSystemConceptDefinitionComponent("concept", e);
- }
- }
-
- protected void composeCodeSystemCodeSystemContactComponent(String name, CodeSystem.CodeSystemContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCodeSystemCodeSystemContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCodeSystemCodeSystemContactComponentElements(CodeSystem.CodeSystemContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeCodeSystemCodeSystemFilterComponent(String name, CodeSystem.CodeSystemFilterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCodeSystemCodeSystemFilterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCodeSystemCodeSystemFilterComponentElements(CodeSystem.CodeSystemFilterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasOperator()) {
- for (CodeType e : element.getOperator())
- composeCode("operator", e);
- }
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- }
-
- protected void composeCodeSystemCodeSystemPropertyComponent(String name, CodeSystem.CodeSystemPropertyComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCodeSystemCodeSystemPropertyComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCodeSystemCodeSystemPropertyComponentElements(CodeSystem.CodeSystemPropertyComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasUriElement()) {
- composeUri("uri", element.getUriElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new CodeSystem.PropertyTypeEnumFactory());
- }
-
- protected void composeCodeSystemConceptDefinitionComponent(String name, CodeSystem.ConceptDefinitionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCodeSystemConceptDefinitionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCodeSystemConceptDefinitionComponentElements(CodeSystem.ConceptDefinitionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasDisplayElement()) {
- composeString("display", element.getDisplayElement());
- }
- if (element.hasDefinitionElement()) {
- composeString("definition", element.getDefinitionElement());
- }
- if (element.hasDesignation()) {
- for (CodeSystem.ConceptDefinitionDesignationComponent e : element.getDesignation())
- composeCodeSystemConceptDefinitionDesignationComponent("designation", e);
- }
- if (element.hasProperty()) {
- for (CodeSystem.ConceptDefinitionPropertyComponent e : element.getProperty())
- composeCodeSystemConceptDefinitionPropertyComponent("property", e);
- }
- if (element.hasConcept()) {
- for (CodeSystem.ConceptDefinitionComponent e : element.getConcept())
- composeCodeSystemConceptDefinitionComponent("concept", e);
- }
- }
-
- protected void composeCodeSystemConceptDefinitionDesignationComponent(String name, CodeSystem.ConceptDefinitionDesignationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCodeSystemConceptDefinitionDesignationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCodeSystemConceptDefinitionDesignationComponentElements(CodeSystem.ConceptDefinitionDesignationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLanguageElement()) {
- composeCode("language", element.getLanguageElement());
- }
- if (element.hasUse()) {
- composeCoding("use", element.getUse());
- }
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- }
-
- protected void composeCodeSystemConceptDefinitionPropertyComponent(String name, CodeSystem.ConceptDefinitionPropertyComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCodeSystemConceptDefinitionPropertyComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCodeSystemConceptDefinitionPropertyComponentElements(CodeSystem.ConceptDefinitionPropertyComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeCommunication(String name, Communication element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCommunicationElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCommunicationElements(Communication element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasCategory()) {
- composeCodeableConcept("category", element.getCategory());
- }
- if (element.hasSender()) {
- composeReference("sender", element.getSender());
- }
- if (element.hasRecipient()) {
- for (Reference e : element.getRecipient())
- composeReference("recipient", e);
- }
- if (element.hasPayload()) {
- for (Communication.CommunicationPayloadComponent e : element.getPayload())
- composeCommunicationCommunicationPayloadComponent("payload", e);
- }
- if (element.hasMedium()) {
- for (CodeableConcept e : element.getMedium())
- composeCodeableConcept("medium", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Communication.CommunicationStatusEnumFactory());
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasSentElement()) {
- composeDateTime("sent", element.getSentElement());
- }
- if (element.hasReceivedElement()) {
- composeDateTime("received", element.getReceivedElement());
- }
- if (element.hasReason()) {
- for (CodeableConcept e : element.getReason())
- composeCodeableConcept("reason", e);
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasRequestDetail()) {
- composeReference("requestDetail", element.getRequestDetail());
- }
- }
-
- protected void composeCommunicationCommunicationPayloadComponent(String name, Communication.CommunicationPayloadComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCommunicationCommunicationPayloadComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCommunicationCommunicationPayloadComponentElements(Communication.CommunicationPayloadComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasContent()) {
- composeType("content", element.getContent());
- } }
-
- protected void composeCommunicationRequest(String name, CommunicationRequest element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCommunicationRequestElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCommunicationRequestElements(CommunicationRequest element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasCategory()) {
- composeCodeableConcept("category", element.getCategory());
- }
- if (element.hasSender()) {
- composeReference("sender", element.getSender());
- }
- if (element.hasRecipient()) {
- for (Reference e : element.getRecipient())
- composeReference("recipient", e);
- }
- if (element.hasPayload()) {
- for (CommunicationRequest.CommunicationRequestPayloadComponent e : element.getPayload())
- composeCommunicationRequestCommunicationRequestPayloadComponent("payload", e);
- }
- if (element.hasMedium()) {
- for (CodeableConcept e : element.getMedium())
- composeCodeableConcept("medium", e);
- }
- if (element.hasRequester()) {
- composeReference("requester", element.getRequester());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new CommunicationRequest.CommunicationRequestStatusEnumFactory());
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasScheduled()) {
- composeType("scheduled", element.getScheduled());
- } if (element.hasReason()) {
- for (CodeableConcept e : element.getReason())
- composeCodeableConcept("reason", e);
- }
- if (element.hasRequestedOnElement()) {
- composeDateTime("requestedOn", element.getRequestedOnElement());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasPriority()) {
- composeCodeableConcept("priority", element.getPriority());
- }
- }
-
- protected void composeCommunicationRequestCommunicationRequestPayloadComponent(String name, CommunicationRequest.CommunicationRequestPayloadComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCommunicationRequestCommunicationRequestPayloadComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCommunicationRequestCommunicationRequestPayloadComponentElements(CommunicationRequest.CommunicationRequestPayloadComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasContent()) {
- composeType("content", element.getContent());
- } }
-
- protected void composeCompartmentDefinition(String name, CompartmentDefinition element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCompartmentDefinitionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCompartmentDefinitionElements(CompartmentDefinition element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (CompartmentDefinition.CompartmentDefinitionContactComponent e : element.getContact())
- composeCompartmentDefinitionCompartmentDefinitionContactComponent("contact", e);
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasRequirementsElement()) {
- composeString("requirements", element.getRequirementsElement());
- }
- if (element.hasCodeElement())
- composeEnumeration("code", element.getCodeElement(), new CompartmentDefinition.CompartmentTypeEnumFactory());
- if (element.hasSearchElement()) {
- composeBoolean("search", element.getSearchElement());
- }
- if (element.hasResource()) {
- for (CompartmentDefinition.CompartmentDefinitionResourceComponent e : element.getResource())
- composeCompartmentDefinitionCompartmentDefinitionResourceComponent("resource", e);
- }
- }
-
- protected void composeCompartmentDefinitionCompartmentDefinitionContactComponent(String name, CompartmentDefinition.CompartmentDefinitionContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCompartmentDefinitionCompartmentDefinitionContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCompartmentDefinitionCompartmentDefinitionContactComponentElements(CompartmentDefinition.CompartmentDefinitionContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeCompartmentDefinitionCompartmentDefinitionResourceComponent(String name, CompartmentDefinition.CompartmentDefinitionResourceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCompartmentDefinitionCompartmentDefinitionResourceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCompartmentDefinitionCompartmentDefinitionResourceComponentElements(CompartmentDefinition.CompartmentDefinitionResourceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasParam()) {
- for (StringType e : element.getParam())
- composeString("param", e);
- }
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- }
-
- protected void composeComposition(String name, Composition element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCompositionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCompositionElements(Composition element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasClass_()) {
- composeCodeableConcept("class", element.getClass_());
- }
- if (element.hasTitleElement()) {
- composeString("title", element.getTitleElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Composition.CompositionStatusEnumFactory());
- if (element.hasConfidentialityElement()) {
- composeCode("confidentiality", element.getConfidentialityElement());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasAuthor()) {
- for (Reference e : element.getAuthor())
- composeReference("author", e);
- }
- if (element.hasAttester()) {
- for (Composition.CompositionAttesterComponent e : element.getAttester())
- composeCompositionCompositionAttesterComponent("attester", e);
- }
- if (element.hasCustodian()) {
- composeReference("custodian", element.getCustodian());
- }
- if (element.hasEvent()) {
- for (Composition.CompositionEventComponent e : element.getEvent())
- composeCompositionCompositionEventComponent("event", e);
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasSection()) {
- for (Composition.SectionComponent e : element.getSection())
- composeCompositionSectionComponent("section", e);
- }
- }
-
- protected void composeCompositionCompositionAttesterComponent(String name, Composition.CompositionAttesterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCompositionCompositionAttesterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCompositionCompositionAttesterComponentElements(Composition.CompositionAttesterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasMode())
- for (Enumeration e : element.getMode())
- composeEnumeration("mode", e, new Composition.CompositionAttestationModeEnumFactory());
- if (element.hasTimeElement()) {
- composeDateTime("time", element.getTimeElement());
- }
- if (element.hasParty()) {
- composeReference("party", element.getParty());
- }
- }
-
- protected void composeCompositionCompositionEventComponent(String name, Composition.CompositionEventComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCompositionCompositionEventComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCompositionCompositionEventComponentElements(Composition.CompositionEventComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- for (CodeableConcept e : element.getCode())
- composeCodeableConcept("code", e);
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasDetail()) {
- for (Reference e : element.getDetail())
- composeReference("detail", e);
- }
- }
-
- protected void composeCompositionSectionComponent(String name, Composition.SectionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCompositionSectionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCompositionSectionComponentElements(Composition.SectionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTitleElement()) {
- composeString("title", element.getTitleElement());
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasText()) {
- composeNarrative("text", element.getText());
- }
- if (element.hasModeElement()) {
- composeCode("mode", element.getModeElement());
- }
- if (element.hasOrderedBy()) {
- composeCodeableConcept("orderedBy", element.getOrderedBy());
- }
- if (element.hasEntry()) {
- for (Reference e : element.getEntry())
- composeReference("entry", e);
- }
- if (element.hasEmptyReason()) {
- composeCodeableConcept("emptyReason", element.getEmptyReason());
- }
- if (element.hasSection()) {
- for (Composition.SectionComponent e : element.getSection())
- composeCompositionSectionComponent("section", e);
- }
- }
-
- protected void composeConceptMap(String name, ConceptMap element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConceptMapElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConceptMapElements(ConceptMap element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (ConceptMap.ConceptMapContactComponent e : element.getContact())
- composeConceptMapConceptMapContactComponent("contact", e);
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasRequirementsElement()) {
- composeString("requirements", element.getRequirementsElement());
- }
- if (element.hasCopyrightElement()) {
- composeString("copyright", element.getCopyrightElement());
- }
- if (element.hasSource()) {
- composeType("source", element.getSource());
- } if (element.hasTarget()) {
- composeType("target", element.getTarget());
- } if (element.hasElement()) {
- for (ConceptMap.SourceElementComponent e : element.getElement())
- composeConceptMapSourceElementComponent("element", e);
- }
- }
-
- protected void composeConceptMapConceptMapContactComponent(String name, ConceptMap.ConceptMapContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConceptMapConceptMapContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConceptMapConceptMapContactComponentElements(ConceptMap.ConceptMapContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeConceptMapSourceElementComponent(String name, ConceptMap.SourceElementComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConceptMapSourceElementComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConceptMapSourceElementComponentElements(ConceptMap.SourceElementComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSystemElement()) {
- composeUri("system", element.getSystemElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasTarget()) {
- for (ConceptMap.TargetElementComponent e : element.getTarget())
- composeConceptMapTargetElementComponent("target", e);
- }
- }
-
- protected void composeConceptMapTargetElementComponent(String name, ConceptMap.TargetElementComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConceptMapTargetElementComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConceptMapTargetElementComponentElements(ConceptMap.TargetElementComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSystemElement()) {
- composeUri("system", element.getSystemElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasEquivalenceElement())
- composeEnumeration("equivalence", element.getEquivalenceElement(), new Enumerations.ConceptMapEquivalenceEnumFactory());
- if (element.hasCommentsElement()) {
- composeString("comments", element.getCommentsElement());
- }
- if (element.hasDependsOn()) {
- for (ConceptMap.OtherElementComponent e : element.getDependsOn())
- composeConceptMapOtherElementComponent("dependsOn", e);
- }
- if (element.hasProduct()) {
- for (ConceptMap.OtherElementComponent e : element.getProduct())
- composeConceptMapOtherElementComponent("product", e);
- }
- }
-
- protected void composeConceptMapOtherElementComponent(String name, ConceptMap.OtherElementComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConceptMapOtherElementComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConceptMapOtherElementComponentElements(ConceptMap.OtherElementComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasElementElement()) {
- composeUri("element", element.getElementElement());
- }
- if (element.hasSystemElement()) {
- composeUri("system", element.getSystemElement());
- }
- if (element.hasCodeElement()) {
- composeString("code", element.getCodeElement());
- }
- }
-
- protected void composeCondition(String name, Condition element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConditionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConditionElements(Condition element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasAsserter()) {
- composeReference("asserter", element.getAsserter());
- }
- if (element.hasDateRecordedElement()) {
- composeDate("dateRecorded", element.getDateRecordedElement());
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasCategory()) {
- composeCodeableConcept("category", element.getCategory());
- }
- if (element.hasClinicalStatusElement()) {
- composeCode("clinicalStatus", element.getClinicalStatusElement());
- }
- if (element.hasVerificationStatusElement())
- composeEnumeration("verificationStatus", element.getVerificationStatusElement(), new Condition.ConditionVerificationStatusEnumFactory());
- if (element.hasSeverity()) {
- composeCodeableConcept("severity", element.getSeverity());
- }
- if (element.hasOnset()) {
- composeType("onset", element.getOnset());
- } if (element.hasAbatement()) {
- composeType("abatement", element.getAbatement());
- } if (element.hasStage()) {
- composeConditionConditionStageComponent("stage", element.getStage());
- }
- if (element.hasEvidence()) {
- for (Condition.ConditionEvidenceComponent e : element.getEvidence())
- composeConditionConditionEvidenceComponent("evidence", e);
- }
- if (element.hasBodySite()) {
- for (CodeableConcept e : element.getBodySite())
- composeCodeableConcept("bodySite", e);
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- }
-
- protected void composeConditionConditionStageComponent(String name, Condition.ConditionStageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConditionConditionStageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConditionConditionStageComponentElements(Condition.ConditionStageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSummary()) {
- composeCodeableConcept("summary", element.getSummary());
- }
- if (element.hasAssessment()) {
- for (Reference e : element.getAssessment())
- composeReference("assessment", e);
- }
- }
-
- protected void composeConditionConditionEvidenceComponent(String name, Condition.ConditionEvidenceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConditionConditionEvidenceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConditionConditionEvidenceComponentElements(Condition.ConditionEvidenceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasDetail()) {
- for (Reference e : element.getDetail())
- composeReference("detail", e);
- }
- }
-
- protected void composeConformance(String name, Conformance element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceElements(Conformance element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (Conformance.ConformanceContactComponent e : element.getContact())
- composeConformanceConformanceContactComponent("contact", e);
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasRequirementsElement()) {
- composeString("requirements", element.getRequirementsElement());
- }
- if (element.hasCopyrightElement()) {
- composeString("copyright", element.getCopyrightElement());
- }
- if (element.hasKindElement())
- composeEnumeration("kind", element.getKindElement(), new Conformance.ConformanceStatementKindEnumFactory());
- if (element.hasSoftware()) {
- composeConformanceConformanceSoftwareComponent("software", element.getSoftware());
- }
- if (element.hasImplementation()) {
- composeConformanceConformanceImplementationComponent("implementation", element.getImplementation());
- }
- if (element.hasFhirVersionElement()) {
- composeId("fhirVersion", element.getFhirVersionElement());
- }
- if (element.hasAcceptUnknownElement())
- composeEnumeration("acceptUnknown", element.getAcceptUnknownElement(), new Conformance.UnknownContentCodeEnumFactory());
- if (element.hasFormat()) {
- for (CodeType e : element.getFormat())
- composeCode("format", e);
- }
- if (element.hasProfile()) {
- for (Reference e : element.getProfile())
- composeReference("profile", e);
- }
- if (element.hasRest()) {
- for (Conformance.ConformanceRestComponent e : element.getRest())
- composeConformanceConformanceRestComponent("rest", e);
- }
- if (element.hasMessaging()) {
- for (Conformance.ConformanceMessagingComponent e : element.getMessaging())
- composeConformanceConformanceMessagingComponent("messaging", e);
- }
- if (element.hasDocument()) {
- for (Conformance.ConformanceDocumentComponent e : element.getDocument())
- composeConformanceConformanceDocumentComponent("document", e);
- }
- }
-
- protected void composeConformanceConformanceContactComponent(String name, Conformance.ConformanceContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceContactComponentElements(Conformance.ConformanceContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeConformanceConformanceSoftwareComponent(String name, Conformance.ConformanceSoftwareComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceSoftwareComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceSoftwareComponentElements(Conformance.ConformanceSoftwareComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasReleaseDateElement()) {
- composeDateTime("releaseDate", element.getReleaseDateElement());
- }
- }
-
- protected void composeConformanceConformanceImplementationComponent(String name, Conformance.ConformanceImplementationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceImplementationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceImplementationComponentElements(Conformance.ConformanceImplementationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- }
-
- protected void composeConformanceConformanceRestComponent(String name, Conformance.ConformanceRestComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceRestComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceRestComponentElements(Conformance.ConformanceRestComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasModeElement())
- composeEnumeration("mode", element.getModeElement(), new Conformance.RestfulConformanceModeEnumFactory());
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- if (element.hasSecurity()) {
- composeConformanceConformanceRestSecurityComponent("security", element.getSecurity());
- }
- if (element.hasResource()) {
- for (Conformance.ConformanceRestResourceComponent e : element.getResource())
- composeConformanceConformanceRestResourceComponent("resource", e);
- }
- if (element.hasInteraction()) {
- for (Conformance.SystemInteractionComponent e : element.getInteraction())
- composeConformanceSystemInteractionComponent("interaction", e);
- }
- if (element.hasTransactionModeElement())
- composeEnumeration("transactionMode", element.getTransactionModeElement(), new Conformance.TransactionModeEnumFactory());
- if (element.hasSearchParam()) {
- for (Conformance.ConformanceRestResourceSearchParamComponent e : element.getSearchParam())
- composeConformanceConformanceRestResourceSearchParamComponent("searchParam", e);
- }
- if (element.hasOperation()) {
- for (Conformance.ConformanceRestOperationComponent e : element.getOperation())
- composeConformanceConformanceRestOperationComponent("operation", e);
- }
- if (element.hasCompartment()) {
- for (UriType e : element.getCompartment())
- composeUri("compartment", e);
- }
- }
-
- protected void composeConformanceConformanceRestSecurityComponent(String name, Conformance.ConformanceRestSecurityComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceRestSecurityComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceRestSecurityComponentElements(Conformance.ConformanceRestSecurityComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCorsElement()) {
- composeBoolean("cors", element.getCorsElement());
- }
- if (element.hasService()) {
- for (CodeableConcept e : element.getService())
- composeCodeableConcept("service", e);
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasCertificate()) {
- for (Conformance.ConformanceRestSecurityCertificateComponent e : element.getCertificate())
- composeConformanceConformanceRestSecurityCertificateComponent("certificate", e);
- }
- }
-
- protected void composeConformanceConformanceRestSecurityCertificateComponent(String name, Conformance.ConformanceRestSecurityCertificateComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceRestSecurityCertificateComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceRestSecurityCertificateComponentElements(Conformance.ConformanceRestSecurityCertificateComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement()) {
- composeCode("type", element.getTypeElement());
- }
- if (element.hasBlobElement()) {
- composeBase64Binary("blob", element.getBlobElement());
- }
- }
-
- protected void composeConformanceConformanceRestResourceComponent(String name, Conformance.ConformanceRestResourceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceRestResourceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceRestResourceComponentElements(Conformance.ConformanceRestResourceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement()) {
- composeCode("type", element.getTypeElement());
- }
- if (element.hasProfile()) {
- composeReference("profile", element.getProfile());
- }
- if (element.hasInteraction()) {
- for (Conformance.ResourceInteractionComponent e : element.getInteraction())
- composeConformanceResourceInteractionComponent("interaction", e);
- }
- if (element.hasVersioningElement())
- composeEnumeration("versioning", element.getVersioningElement(), new Conformance.ResourceVersionPolicyEnumFactory());
- if (element.hasReadHistoryElement()) {
- composeBoolean("readHistory", element.getReadHistoryElement());
- }
- if (element.hasUpdateCreateElement()) {
- composeBoolean("updateCreate", element.getUpdateCreateElement());
- }
- if (element.hasConditionalCreateElement()) {
- composeBoolean("conditionalCreate", element.getConditionalCreateElement());
- }
- if (element.hasConditionalUpdateElement()) {
- composeBoolean("conditionalUpdate", element.getConditionalUpdateElement());
- }
- if (element.hasConditionalDeleteElement())
- composeEnumeration("conditionalDelete", element.getConditionalDeleteElement(), new Conformance.ConditionalDeleteStatusEnumFactory());
- if (element.hasSearchInclude()) {
- for (StringType e : element.getSearchInclude())
- composeString("searchInclude", e);
- }
- if (element.hasSearchRevInclude()) {
- for (StringType e : element.getSearchRevInclude())
- composeString("searchRevInclude", e);
- }
- if (element.hasSearchParam()) {
- for (Conformance.ConformanceRestResourceSearchParamComponent e : element.getSearchParam())
- composeConformanceConformanceRestResourceSearchParamComponent("searchParam", e);
- }
- }
-
- protected void composeConformanceResourceInteractionComponent(String name, Conformance.ResourceInteractionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceResourceInteractionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceResourceInteractionComponentElements(Conformance.ResourceInteractionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeElement())
- composeEnumeration("code", element.getCodeElement(), new Conformance.TypeRestfulInteractionEnumFactory());
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- }
-
- protected void composeConformanceConformanceRestResourceSearchParamComponent(String name, Conformance.ConformanceRestResourceSearchParamComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceRestResourceSearchParamComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceRestResourceSearchParamComponentElements(Conformance.ConformanceRestResourceSearchParamComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDefinitionElement()) {
- composeUri("definition", element.getDefinitionElement());
- }
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Enumerations.SearchParamTypeEnumFactory());
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- if (element.hasTarget()) {
- for (CodeType e : element.getTarget())
- composeCode("target", e);
- }
- if (element.hasModifier())
- for (Enumeration e : element.getModifier())
- composeEnumeration("modifier", e, new Conformance.SearchModifierCodeEnumFactory());
- if (element.hasChain()) {
- for (StringType e : element.getChain())
- composeString("chain", e);
- }
- }
-
- protected void composeConformanceSystemInteractionComponent(String name, Conformance.SystemInteractionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceSystemInteractionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceSystemInteractionComponentElements(Conformance.SystemInteractionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeElement())
- composeEnumeration("code", element.getCodeElement(), new Conformance.SystemRestfulInteractionEnumFactory());
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- }
-
- protected void composeConformanceConformanceRestOperationComponent(String name, Conformance.ConformanceRestOperationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceRestOperationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceRestOperationComponentElements(Conformance.ConformanceRestOperationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDefinition()) {
- composeReference("definition", element.getDefinition());
- }
- }
-
- protected void composeConformanceConformanceMessagingComponent(String name, Conformance.ConformanceMessagingComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceMessagingComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceMessagingComponentElements(Conformance.ConformanceMessagingComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasEndpoint()) {
- for (Conformance.ConformanceMessagingEndpointComponent e : element.getEndpoint())
- composeConformanceConformanceMessagingEndpointComponent("endpoint", e);
- }
- if (element.hasReliableCacheElement()) {
- composeUnsignedInt("reliableCache", element.getReliableCacheElement());
- }
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- if (element.hasEvent()) {
- for (Conformance.ConformanceMessagingEventComponent e : element.getEvent())
- composeConformanceConformanceMessagingEventComponent("event", e);
- }
- }
-
- protected void composeConformanceConformanceMessagingEndpointComponent(String name, Conformance.ConformanceMessagingEndpointComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceMessagingEndpointComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceMessagingEndpointComponentElements(Conformance.ConformanceMessagingEndpointComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasProtocol()) {
- composeCoding("protocol", element.getProtocol());
- }
- if (element.hasAddressElement()) {
- composeUri("address", element.getAddressElement());
- }
- }
-
- protected void composeConformanceConformanceMessagingEventComponent(String name, Conformance.ConformanceMessagingEventComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceMessagingEventComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceMessagingEventComponentElements(Conformance.ConformanceMessagingEventComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- composeCoding("code", element.getCode());
- }
- if (element.hasCategoryElement())
- composeEnumeration("category", element.getCategoryElement(), new Conformance.MessageSignificanceCategoryEnumFactory());
- if (element.hasModeElement())
- composeEnumeration("mode", element.getModeElement(), new Conformance.ConformanceEventModeEnumFactory());
- if (element.hasFocusElement()) {
- composeCode("focus", element.getFocusElement());
- }
- if (element.hasRequest()) {
- composeReference("request", element.getRequest());
- }
- if (element.hasResponse()) {
- composeReference("response", element.getResponse());
- }
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- }
-
- protected void composeConformanceConformanceDocumentComponent(String name, Conformance.ConformanceDocumentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConformanceConformanceDocumentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConformanceConformanceDocumentComponentElements(Conformance.ConformanceDocumentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasModeElement())
- composeEnumeration("mode", element.getModeElement(), new Conformance.DocumentModeEnumFactory());
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- if (element.hasProfile()) {
- composeReference("profile", element.getProfile());
- }
- }
-
- protected void composeConsent(String name, Consent element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConsentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConsentElements(Consent element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Consent.ConsentStatusEnumFactory());
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasIssuedElement()) {
- composeDateTime("issued", element.getIssuedElement());
- }
- if (element.hasApplies()) {
- composePeriod("applies", element.getApplies());
- }
- if (element.hasTopic()) {
- for (Reference e : element.getTopic())
- composeReference("topic", e);
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasAuthority()) {
- for (Reference e : element.getAuthority())
- composeReference("authority", e);
- }
- if (element.hasDomain()) {
- for (Reference e : element.getDomain())
- composeReference("domain", e);
- }
- if (element.hasAction()) {
- for (CodeableConcept e : element.getAction())
- composeCodeableConcept("action", e);
- }
- if (element.hasAgent()) {
- for (Consent.AgentComponent e : element.getAgent())
- composeConsentAgentComponent("agent", e);
- }
- if (element.hasExcept()) {
- for (Consent.ExceptComponent e : element.getExcept())
- composeConsentExceptComponent("except", e);
- }
- if (element.hasFriendly()) {
- for (Consent.FriendlyLanguageComponent e : element.getFriendly())
- composeConsentFriendlyLanguageComponent("friendly", e);
- }
- if (element.hasLegal()) {
- for (Consent.LegalLanguageComponent e : element.getLegal())
- composeConsentLegalLanguageComponent("legal", e);
- }
- if (element.hasRule()) {
- for (Attachment e : element.getRule())
- composeAttachment("rule", e);
- }
- }
-
- protected void composeConsentAgentComponent(String name, Consent.AgentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConsentAgentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConsentAgentComponentElements(Consent.AgentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasRole()) {
- for (CodeableConcept e : element.getRole())
- composeCodeableConcept("role", e);
- }
- }
-
- protected void composeConsentExceptComponent(String name, Consent.ExceptComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConsentExceptComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConsentExceptComponentElements(Consent.ExceptComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasApplies()) {
- composePeriod("applies", element.getApplies());
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasSubType()) {
- composeCodeableConcept("subType", element.getSubType());
- }
- if (element.hasTopic()) {
- for (Reference e : element.getTopic())
- composeReference("topic", e);
- }
- if (element.hasAction()) {
- for (CodeableConcept e : element.getAction())
- composeCodeableConcept("action", e);
- }
- if (element.hasAgent()) {
- for (Consent.ExceptAgentComponent e : element.getAgent())
- composeConsentExceptAgentComponent("agent", e);
- }
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- }
-
- protected void composeConsentExceptAgentComponent(String name, Consent.ExceptAgentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConsentExceptAgentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConsentExceptAgentComponentElements(Consent.ExceptAgentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasRole()) {
- for (CodeableConcept e : element.getRole())
- composeCodeableConcept("role", e);
- }
- }
-
- protected void composeConsentFriendlyLanguageComponent(String name, Consent.FriendlyLanguageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConsentFriendlyLanguageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConsentFriendlyLanguageComponentElements(Consent.FriendlyLanguageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasContent()) {
- composeType("content", element.getContent());
- } }
-
- protected void composeConsentLegalLanguageComponent(String name, Consent.LegalLanguageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeConsentLegalLanguageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeConsentLegalLanguageComponentElements(Consent.LegalLanguageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasContent()) {
- composeType("content", element.getContent());
- } }
-
- protected void composeContract(String name, Contract element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeContractElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeContractElements(Contract element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasIssuedElement()) {
- composeDateTime("issued", element.getIssuedElement());
- }
- if (element.hasApplies()) {
- composePeriod("applies", element.getApplies());
- }
- if (element.hasSubject()) {
- for (Reference e : element.getSubject())
- composeReference("subject", e);
- }
- if (element.hasTopic()) {
- for (Reference e : element.getTopic())
- composeReference("topic", e);
- }
- if (element.hasAuthority()) {
- for (Reference e : element.getAuthority())
- composeReference("authority", e);
- }
- if (element.hasDomain()) {
- for (Reference e : element.getDomain())
- composeReference("domain", e);
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasSubType()) {
- for (CodeableConcept e : element.getSubType())
- composeCodeableConcept("subType", e);
- }
- if (element.hasAction()) {
- for (CodeableConcept e : element.getAction())
- composeCodeableConcept("action", e);
- }
- if (element.hasActionReason()) {
- for (CodeableConcept e : element.getActionReason())
- composeCodeableConcept("actionReason", e);
- }
- if (element.hasAgent()) {
- for (Contract.AgentComponent e : element.getAgent())
- composeContractAgentComponent("agent", e);
- }
- if (element.hasSigner()) {
- for (Contract.SignatoryComponent e : element.getSigner())
- composeContractSignatoryComponent("signer", e);
- }
- if (element.hasValuedItem()) {
- for (Contract.ValuedItemComponent e : element.getValuedItem())
- composeContractValuedItemComponent("valuedItem", e);
- }
- if (element.hasTerm()) {
- for (Contract.TermComponent e : element.getTerm())
- composeContractTermComponent("term", e);
- }
- if (element.hasBinding()) {
- composeType("binding", element.getBinding());
- } if (element.hasFriendly()) {
- for (Contract.FriendlyLanguageComponent e : element.getFriendly())
- composeContractFriendlyLanguageComponent("friendly", e);
- }
- if (element.hasLegal()) {
- for (Contract.LegalLanguageComponent e : element.getLegal())
- composeContractLegalLanguageComponent("legal", e);
- }
- if (element.hasRule()) {
- for (Contract.ComputableLanguageComponent e : element.getRule())
- composeContractComputableLanguageComponent("rule", e);
- }
- }
-
- protected void composeContractAgentComponent(String name, Contract.AgentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeContractAgentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeContractAgentComponentElements(Contract.AgentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasRole()) {
- for (CodeableConcept e : element.getRole())
- composeCodeableConcept("role", e);
- }
- }
-
- protected void composeContractSignatoryComponent(String name, Contract.SignatoryComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeContractSignatoryComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeContractSignatoryComponentElements(Contract.SignatoryComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasParty()) {
- composeReference("party", element.getParty());
- }
- if (element.hasSignature()) {
- for (Signature e : element.getSignature())
- composeSignature("signature", e);
- }
- }
-
- protected void composeContractValuedItemComponent(String name, Contract.ValuedItemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeContractValuedItemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeContractValuedItemComponentElements(Contract.ValuedItemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasEntity()) {
- composeType("entity", element.getEntity());
- } if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasEffectiveTimeElement()) {
- composeDateTime("effectiveTime", element.getEffectiveTimeElement());
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasUnitPrice()) {
- composeMoney("unitPrice", element.getUnitPrice());
- }
- if (element.hasFactorElement()) {
- composeDecimal("factor", element.getFactorElement());
- }
- if (element.hasPointsElement()) {
- composeDecimal("points", element.getPointsElement());
- }
- if (element.hasNet()) {
- composeMoney("net", element.getNet());
- }
- }
-
- protected void composeContractTermComponent(String name, Contract.TermComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeContractTermComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeContractTermComponentElements(Contract.TermComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasIssuedElement()) {
- composeDateTime("issued", element.getIssuedElement());
- }
- if (element.hasApplies()) {
- composePeriod("applies", element.getApplies());
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasSubType()) {
- composeCodeableConcept("subType", element.getSubType());
- }
- if (element.hasTopic()) {
- for (Reference e : element.getTopic())
- composeReference("topic", e);
- }
- if (element.hasAction()) {
- for (CodeableConcept e : element.getAction())
- composeCodeableConcept("action", e);
- }
- if (element.hasActionReason()) {
- for (CodeableConcept e : element.getActionReason())
- composeCodeableConcept("actionReason", e);
- }
- if (element.hasAgent()) {
- for (Contract.TermAgentComponent e : element.getAgent())
- composeContractTermAgentComponent("agent", e);
- }
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- if (element.hasValuedItem()) {
- for (Contract.TermValuedItemComponent e : element.getValuedItem())
- composeContractTermValuedItemComponent("valuedItem", e);
- }
- if (element.hasGroup()) {
- for (Contract.TermComponent e : element.getGroup())
- composeContractTermComponent("group", e);
- }
- }
-
- protected void composeContractTermAgentComponent(String name, Contract.TermAgentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeContractTermAgentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeContractTermAgentComponentElements(Contract.TermAgentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasRole()) {
- for (CodeableConcept e : element.getRole())
- composeCodeableConcept("role", e);
- }
- }
-
- protected void composeContractTermValuedItemComponent(String name, Contract.TermValuedItemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeContractTermValuedItemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeContractTermValuedItemComponentElements(Contract.TermValuedItemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasEntity()) {
- composeType("entity", element.getEntity());
- } if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasEffectiveTimeElement()) {
- composeDateTime("effectiveTime", element.getEffectiveTimeElement());
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasUnitPrice()) {
- composeMoney("unitPrice", element.getUnitPrice());
- }
- if (element.hasFactorElement()) {
- composeDecimal("factor", element.getFactorElement());
- }
- if (element.hasPointsElement()) {
- composeDecimal("points", element.getPointsElement());
- }
- if (element.hasNet()) {
- composeMoney("net", element.getNet());
- }
- }
-
- protected void composeContractFriendlyLanguageComponent(String name, Contract.FriendlyLanguageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeContractFriendlyLanguageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeContractFriendlyLanguageComponentElements(Contract.FriendlyLanguageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasContent()) {
- composeType("content", element.getContent());
- } }
-
- protected void composeContractLegalLanguageComponent(String name, Contract.LegalLanguageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeContractLegalLanguageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeContractLegalLanguageComponentElements(Contract.LegalLanguageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasContent()) {
- composeType("content", element.getContent());
- } }
-
- protected void composeContractComputableLanguageComponent(String name, Contract.ComputableLanguageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeContractComputableLanguageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeContractComputableLanguageComponentElements(Contract.ComputableLanguageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasContent()) {
- composeType("content", element.getContent());
- } }
-
- protected void composeCoverage(String name, Coverage element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeCoverageElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeCoverageElements(Coverage element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIssuer()) {
- composeType("issuer", element.getIssuer());
- } if (element.hasIsAgreementElement()) {
- composeBoolean("isAgreement", element.getIsAgreementElement());
- }
- if (element.hasBinElement()) {
- composeString("bin", element.getBinElement());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasPlanholder()) {
- composeType("planholder", element.getPlanholder());
- } if (element.hasBeneficiary()) {
- composeType("beneficiary", element.getBeneficiary());
- } if (element.hasRelationship()) {
- composeCoding("relationship", element.getRelationship());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasGroupElement()) {
- composeString("group", element.getGroupElement());
- }
- if (element.hasPlanElement()) {
- composeString("plan", element.getPlanElement());
- }
- if (element.hasSubPlanElement()) {
- composeString("subPlan", element.getSubPlanElement());
- }
- if (element.hasDependentElement()) {
- composePositiveInt("dependent", element.getDependentElement());
- }
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasException()) {
- for (Coding e : element.getException())
- composeCoding("exception", e);
- }
- if (element.hasSchoolElement()) {
- composeString("school", element.getSchoolElement());
- }
- if (element.hasNetworkElement()) {
- composeString("network", element.getNetworkElement());
- }
- if (element.hasContract()) {
- for (Reference e : element.getContract())
- composeReference("contract", e);
- }
- }
-
- protected void composeDataElement(String name, DataElement element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDataElementElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDataElementElements(DataElement element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasContact()) {
- for (DataElement.DataElementContactComponent e : element.getContact())
- composeDataElementDataElementContactComponent("contact", e);
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasCopyrightElement()) {
- composeString("copyright", element.getCopyrightElement());
- }
- if (element.hasStringencyElement())
- composeEnumeration("stringency", element.getStringencyElement(), new DataElement.DataElementStringencyEnumFactory());
- if (element.hasMapping()) {
- for (DataElement.DataElementMappingComponent e : element.getMapping())
- composeDataElementDataElementMappingComponent("mapping", e);
- }
- if (element.hasElement()) {
- for (ElementDefinition e : element.getElement())
- composeElementDefinition("element", e);
- }
- }
-
- protected void composeDataElementDataElementContactComponent(String name, DataElement.DataElementContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDataElementDataElementContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDataElementDataElementContactComponentElements(DataElement.DataElementContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeDataElementDataElementMappingComponent(String name, DataElement.DataElementMappingComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDataElementDataElementMappingComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDataElementDataElementMappingComponentElements(DataElement.DataElementMappingComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentityElement()) {
- composeId("identity", element.getIdentityElement());
- }
- if (element.hasUriElement()) {
- composeUri("uri", element.getUriElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasCommentElement()) {
- composeString("comment", element.getCommentElement());
- }
- }
-
- protected void composeDecisionSupportRule(String name, DecisionSupportRule element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDecisionSupportRuleElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDecisionSupportRuleElements(DecisionSupportRule element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasModuleMetadata()) {
- composeModuleMetadata("moduleMetadata", element.getModuleMetadata());
- }
- if (element.hasLibrary()) {
- for (Reference e : element.getLibrary())
- composeReference("library", e);
- }
- if (element.hasTrigger()) {
- for (TriggerDefinition e : element.getTrigger())
- composeTriggerDefinition("trigger", e);
- }
- if (element.hasConditionElement()) {
- composeString("condition", element.getConditionElement());
- }
- if (element.hasAction()) {
- for (ActionDefinition e : element.getAction())
- composeActionDefinition("action", e);
- }
- }
-
- protected void composeDecisionSupportServiceModule(String name, DecisionSupportServiceModule element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDecisionSupportServiceModuleElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDecisionSupportServiceModuleElements(DecisionSupportServiceModule element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasModuleMetadata()) {
- composeModuleMetadata("moduleMetadata", element.getModuleMetadata());
- }
- if (element.hasTrigger()) {
- for (TriggerDefinition e : element.getTrigger())
- composeTriggerDefinition("trigger", e);
- }
- if (element.hasParameter()) {
- for (ParameterDefinition e : element.getParameter())
- composeParameterDefinition("parameter", e);
- }
- if (element.hasDataRequirement()) {
- for (DataRequirement e : element.getDataRequirement())
- composeDataRequirement("dataRequirement", e);
- }
- }
-
- protected void composeDetectedIssue(String name, DetectedIssue element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDetectedIssueElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDetectedIssueElements(DetectedIssue element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasCategory()) {
- composeCodeableConcept("category", element.getCategory());
- }
- if (element.hasSeverityElement())
- composeEnumeration("severity", element.getSeverityElement(), new DetectedIssue.DetectedIssueSeverityEnumFactory());
- if (element.hasImplicated()) {
- for (Reference e : element.getImplicated())
- composeReference("implicated", e);
- }
- if (element.hasDetailElement()) {
- composeString("detail", element.getDetailElement());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasAuthor()) {
- composeReference("author", element.getAuthor());
- }
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasReferenceElement()) {
- composeUri("reference", element.getReferenceElement());
- }
- if (element.hasMitigation()) {
- for (DetectedIssue.DetectedIssueMitigationComponent e : element.getMitigation())
- composeDetectedIssueDetectedIssueMitigationComponent("mitigation", e);
- }
- }
-
- protected void composeDetectedIssueDetectedIssueMitigationComponent(String name, DetectedIssue.DetectedIssueMitigationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDetectedIssueDetectedIssueMitigationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDetectedIssueDetectedIssueMitigationComponentElements(DetectedIssue.DetectedIssueMitigationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasAction()) {
- composeCodeableConcept("action", element.getAction());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasAuthor()) {
- composeReference("author", element.getAuthor());
- }
- }
-
- protected void composeDevice(String name, Device element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDeviceElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDeviceElements(Device element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasUdiCarrier()) {
- composeIdentifier("udiCarrier", element.getUdiCarrier());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Device.DeviceStatusEnumFactory());
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasLotNumberElement()) {
- composeString("lotNumber", element.getLotNumberElement());
- }
- if (element.hasManufacturerElement()) {
- composeString("manufacturer", element.getManufacturerElement());
- }
- if (element.hasManufactureDateElement()) {
- composeDateTime("manufactureDate", element.getManufactureDateElement());
- }
- if (element.hasExpirationDateElement()) {
- composeDateTime("expirationDate", element.getExpirationDateElement());
- }
- if (element.hasModelElement()) {
- composeString("model", element.getModelElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasOwner()) {
- composeReference("owner", element.getOwner());
- }
- if (element.hasContact()) {
- for (ContactPoint e : element.getContact())
- composeContactPoint("contact", e);
- }
- if (element.hasLocation()) {
- composeReference("location", element.getLocation());
- }
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- }
-
- protected void composeDeviceComponent(String name, DeviceComponent element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDeviceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDeviceComponentElements(DeviceComponent element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasLastSystemChangeElement()) {
- composeInstant("lastSystemChange", element.getLastSystemChangeElement());
- }
- if (element.hasSource()) {
- composeReference("source", element.getSource());
- }
- if (element.hasParent()) {
- composeReference("parent", element.getParent());
- }
- if (element.hasOperationalStatus()) {
- for (CodeableConcept e : element.getOperationalStatus())
- composeCodeableConcept("operationalStatus", e);
- }
- if (element.hasParameterGroup()) {
- composeCodeableConcept("parameterGroup", element.getParameterGroup());
- }
- if (element.hasMeasurementPrincipleElement())
- composeEnumeration("measurementPrinciple", element.getMeasurementPrincipleElement(), new DeviceComponent.MeasmntPrincipleEnumFactory());
- if (element.hasProductionSpecification()) {
- for (DeviceComponent.DeviceComponentProductionSpecificationComponent e : element.getProductionSpecification())
- composeDeviceComponentDeviceComponentProductionSpecificationComponent("productionSpecification", e);
- }
- if (element.hasLanguageCode()) {
- composeCodeableConcept("languageCode", element.getLanguageCode());
- }
- }
-
- protected void composeDeviceComponentDeviceComponentProductionSpecificationComponent(String name, DeviceComponent.DeviceComponentProductionSpecificationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDeviceComponentDeviceComponentProductionSpecificationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDeviceComponentDeviceComponentProductionSpecificationComponentElements(DeviceComponent.DeviceComponentProductionSpecificationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSpecType()) {
- composeCodeableConcept("specType", element.getSpecType());
- }
- if (element.hasComponentId()) {
- composeIdentifier("componentId", element.getComponentId());
- }
- if (element.hasProductionSpecElement()) {
- composeString("productionSpec", element.getProductionSpecElement());
- }
- }
-
- protected void composeDeviceMetric(String name, DeviceMetric element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDeviceMetricElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDeviceMetricElements(DeviceMetric element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasUnit()) {
- composeCodeableConcept("unit", element.getUnit());
- }
- if (element.hasSource()) {
- composeReference("source", element.getSource());
- }
- if (element.hasParent()) {
- composeReference("parent", element.getParent());
- }
- if (element.hasOperationalStatusElement())
- composeEnumeration("operationalStatus", element.getOperationalStatusElement(), new DeviceMetric.DeviceMetricOperationalStatusEnumFactory());
- if (element.hasColorElement())
- composeEnumeration("color", element.getColorElement(), new DeviceMetric.DeviceMetricColorEnumFactory());
- if (element.hasCategoryElement())
- composeEnumeration("category", element.getCategoryElement(), new DeviceMetric.DeviceMetricCategoryEnumFactory());
- if (element.hasMeasurementPeriod()) {
- composeTiming("measurementPeriod", element.getMeasurementPeriod());
- }
- if (element.hasCalibration()) {
- for (DeviceMetric.DeviceMetricCalibrationComponent e : element.getCalibration())
- composeDeviceMetricDeviceMetricCalibrationComponent("calibration", e);
- }
- }
-
- protected void composeDeviceMetricDeviceMetricCalibrationComponent(String name, DeviceMetric.DeviceMetricCalibrationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDeviceMetricDeviceMetricCalibrationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDeviceMetricDeviceMetricCalibrationComponentElements(DeviceMetric.DeviceMetricCalibrationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new DeviceMetric.DeviceMetricCalibrationTypeEnumFactory());
- if (element.hasStateElement())
- composeEnumeration("state", element.getStateElement(), new DeviceMetric.DeviceMetricCalibrationStateEnumFactory());
- if (element.hasTimeElement()) {
- composeInstant("time", element.getTimeElement());
- }
- }
-
- protected void composeDeviceUseRequest(String name, DeviceUseRequest element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDeviceUseRequestElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDeviceUseRequestElements(DeviceUseRequest element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasBodySite()) {
- composeType("bodySite", element.getBodySite());
- } if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new DeviceUseRequest.DeviceUseRequestStatusEnumFactory());
- if (element.hasDevice()) {
- composeReference("device", element.getDevice());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasIndication()) {
- for (CodeableConcept e : element.getIndication())
- composeCodeableConcept("indication", e);
- }
- if (element.hasNotes()) {
- for (StringType e : element.getNotes())
- composeString("notes", e);
- }
- if (element.hasPrnReason()) {
- for (CodeableConcept e : element.getPrnReason())
- composeCodeableConcept("prnReason", e);
- }
- if (element.hasOrderedOnElement()) {
- composeDateTime("orderedOn", element.getOrderedOnElement());
- }
- if (element.hasRecordedOnElement()) {
- composeDateTime("recordedOn", element.getRecordedOnElement());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasTiming()) {
- composeType("timing", element.getTiming());
- } if (element.hasPriorityElement())
- composeEnumeration("priority", element.getPriorityElement(), new DeviceUseRequest.DeviceUseRequestPriorityEnumFactory());
- }
-
- protected void composeDeviceUseStatement(String name, DeviceUseStatement element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDeviceUseStatementElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDeviceUseStatementElements(DeviceUseStatement element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasBodySite()) {
- composeType("bodySite", element.getBodySite());
- } if (element.hasWhenUsed()) {
- composePeriod("whenUsed", element.getWhenUsed());
- }
- if (element.hasDevice()) {
- composeReference("device", element.getDevice());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasIndication()) {
- for (CodeableConcept e : element.getIndication())
- composeCodeableConcept("indication", e);
- }
- if (element.hasNotes()) {
- for (StringType e : element.getNotes())
- composeString("notes", e);
- }
- if (element.hasRecordedOnElement()) {
- composeDateTime("recordedOn", element.getRecordedOnElement());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasTiming()) {
- composeType("timing", element.getTiming());
- } }
-
- protected void composeDiagnosticOrder(String name, DiagnosticOrder element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDiagnosticOrderElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDiagnosticOrderElements(DiagnosticOrder element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new DiagnosticOrder.DiagnosticOrderStatusEnumFactory());
- if (element.hasPriorityElement())
- composeEnumeration("priority", element.getPriorityElement(), new DiagnosticOrder.DiagnosticOrderPriorityEnumFactory());
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasOrderer()) {
- composeReference("orderer", element.getOrderer());
- }
- if (element.hasReason()) {
- for (CodeableConcept e : element.getReason())
- composeCodeableConcept("reason", e);
- }
- if (element.hasSupportingInformation()) {
- for (Reference e : element.getSupportingInformation())
- composeReference("supportingInformation", e);
- }
- if (element.hasEvent()) {
- for (DiagnosticOrder.DiagnosticOrderEventComponent e : element.getEvent())
- composeDiagnosticOrderDiagnosticOrderEventComponent("event", e);
- }
- if (element.hasItem()) {
- for (DiagnosticOrder.DiagnosticOrderItemComponent e : element.getItem())
- composeDiagnosticOrderDiagnosticOrderItemComponent("item", e);
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- }
-
- protected void composeDiagnosticOrderDiagnosticOrderEventComponent(String name, DiagnosticOrder.DiagnosticOrderEventComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDiagnosticOrderDiagnosticOrderEventComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDiagnosticOrderDiagnosticOrderEventComponentElements(DiagnosticOrder.DiagnosticOrderEventComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new DiagnosticOrder.DiagnosticOrderStatusEnumFactory());
- if (element.hasDescription()) {
- composeCodeableConcept("description", element.getDescription());
- }
- if (element.hasDateTimeElement()) {
- composeDateTime("dateTime", element.getDateTimeElement());
- }
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- }
-
- protected void composeDiagnosticOrderDiagnosticOrderItemComponent(String name, DiagnosticOrder.DiagnosticOrderItemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDiagnosticOrderDiagnosticOrderItemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDiagnosticOrderDiagnosticOrderItemComponentElements(DiagnosticOrder.DiagnosticOrderItemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasBodySite()) {
- composeCodeableConcept("bodySite", element.getBodySite());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new DiagnosticOrder.DiagnosticOrderStatusEnumFactory());
- if (element.hasEvent()) {
- for (DiagnosticOrder.DiagnosticOrderEventComponent e : element.getEvent())
- composeDiagnosticOrderDiagnosticOrderEventComponent("event", e);
- }
- }
-
- protected void composeDiagnosticReport(String name, DiagnosticReport element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDiagnosticReportElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDiagnosticReportElements(DiagnosticReport element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new DiagnosticReport.DiagnosticReportStatusEnumFactory());
- if (element.hasCategory()) {
- composeCodeableConcept("category", element.getCategory());
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasEffective()) {
- composeType("effective", element.getEffective());
- } if (element.hasIssuedElement()) {
- composeInstant("issued", element.getIssuedElement());
- }
- if (element.hasPerformer()) {
- for (Reference e : element.getPerformer())
- composeReference("performer", e);
- }
- if (element.hasRequest()) {
- for (Reference e : element.getRequest())
- composeReference("request", e);
- }
- if (element.hasSpecimen()) {
- for (Reference e : element.getSpecimen())
- composeReference("specimen", e);
- }
- if (element.hasResult()) {
- for (Reference e : element.getResult())
- composeReference("result", e);
- }
- if (element.hasImagingStudy()) {
- for (Reference e : element.getImagingStudy())
- composeReference("imagingStudy", e);
- }
- if (element.hasImage()) {
- for (DiagnosticReport.DiagnosticReportImageComponent e : element.getImage())
- composeDiagnosticReportDiagnosticReportImageComponent("image", e);
- }
- if (element.hasConclusionElement()) {
- composeString("conclusion", element.getConclusionElement());
- }
- if (element.hasCodedDiagnosis()) {
- for (CodeableConcept e : element.getCodedDiagnosis())
- composeCodeableConcept("codedDiagnosis", e);
- }
- if (element.hasPresentedForm()) {
- for (Attachment e : element.getPresentedForm())
- composeAttachment("presentedForm", e);
- }
- }
-
- protected void composeDiagnosticReportDiagnosticReportImageComponent(String name, DiagnosticReport.DiagnosticReportImageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDiagnosticReportDiagnosticReportImageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDiagnosticReportDiagnosticReportImageComponentElements(DiagnosticReport.DiagnosticReportImageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCommentElement()) {
- composeString("comment", element.getCommentElement());
- }
- if (element.hasLink()) {
- composeReference("link", element.getLink());
- }
- }
-
- protected void composeDocumentManifest(String name, DocumentManifest element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDocumentManifestElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDocumentManifestElements(DocumentManifest element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasMasterIdentifier()) {
- composeIdentifier("masterIdentifier", element.getMasterIdentifier());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasRecipient()) {
- for (Reference e : element.getRecipient())
- composeReference("recipient", e);
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasAuthor()) {
- for (Reference e : element.getAuthor())
- composeReference("author", e);
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasSourceElement()) {
- composeUri("source", element.getSourceElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.DocumentReferenceStatusEnumFactory());
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasContent()) {
- for (DocumentManifest.DocumentManifestContentComponent e : element.getContent())
- composeDocumentManifestDocumentManifestContentComponent("content", e);
- }
- if (element.hasRelated()) {
- for (DocumentManifest.DocumentManifestRelatedComponent e : element.getRelated())
- composeDocumentManifestDocumentManifestRelatedComponent("related", e);
- }
- }
-
- protected void composeDocumentManifestDocumentManifestContentComponent(String name, DocumentManifest.DocumentManifestContentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDocumentManifestDocumentManifestContentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDocumentManifestDocumentManifestContentComponentElements(DocumentManifest.DocumentManifestContentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasP()) {
- composeType("p", element.getP());
- } }
-
- protected void composeDocumentManifestDocumentManifestRelatedComponent(String name, DocumentManifest.DocumentManifestRelatedComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDocumentManifestDocumentManifestRelatedComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDocumentManifestDocumentManifestRelatedComponentElements(DocumentManifest.DocumentManifestRelatedComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasRef()) {
- composeReference("ref", element.getRef());
- }
- }
-
- protected void composeDocumentReference(String name, DocumentReference element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDocumentReferenceElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDocumentReferenceElements(DocumentReference element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasMasterIdentifier()) {
- composeIdentifier("masterIdentifier", element.getMasterIdentifier());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasClass_()) {
- composeCodeableConcept("class", element.getClass_());
- }
- if (element.hasAuthor()) {
- for (Reference e : element.getAuthor())
- composeReference("author", e);
- }
- if (element.hasCustodian()) {
- composeReference("custodian", element.getCustodian());
- }
- if (element.hasAuthenticator()) {
- composeReference("authenticator", element.getAuthenticator());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasIndexedElement()) {
- composeInstant("indexed", element.getIndexedElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.DocumentReferenceStatusEnumFactory());
- if (element.hasDocStatus()) {
- composeCodeableConcept("docStatus", element.getDocStatus());
- }
- if (element.hasRelatesTo()) {
- for (DocumentReference.DocumentReferenceRelatesToComponent e : element.getRelatesTo())
- composeDocumentReferenceDocumentReferenceRelatesToComponent("relatesTo", e);
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasSecurityLabel()) {
- for (CodeableConcept e : element.getSecurityLabel())
- composeCodeableConcept("securityLabel", e);
- }
- if (element.hasContent()) {
- for (DocumentReference.DocumentReferenceContentComponent e : element.getContent())
- composeDocumentReferenceDocumentReferenceContentComponent("content", e);
- }
- if (element.hasContext()) {
- composeDocumentReferenceDocumentReferenceContextComponent("context", element.getContext());
- }
- }
-
- protected void composeDocumentReferenceDocumentReferenceRelatesToComponent(String name, DocumentReference.DocumentReferenceRelatesToComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDocumentReferenceDocumentReferenceRelatesToComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDocumentReferenceDocumentReferenceRelatesToComponentElements(DocumentReference.DocumentReferenceRelatesToComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeElement())
- composeEnumeration("code", element.getCodeElement(), new DocumentReference.DocumentRelationshipTypeEnumFactory());
- if (element.hasTarget()) {
- composeReference("target", element.getTarget());
- }
- }
-
- protected void composeDocumentReferenceDocumentReferenceContentComponent(String name, DocumentReference.DocumentReferenceContentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDocumentReferenceDocumentReferenceContentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDocumentReferenceDocumentReferenceContentComponentElements(DocumentReference.DocumentReferenceContentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasAttachment()) {
- composeAttachment("attachment", element.getAttachment());
- }
- if (element.hasFormat()) {
- for (Coding e : element.getFormat())
- composeCoding("format", e);
- }
- }
-
- protected void composeDocumentReferenceDocumentReferenceContextComponent(String name, DocumentReference.DocumentReferenceContextComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDocumentReferenceDocumentReferenceContextComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDocumentReferenceDocumentReferenceContextComponentElements(DocumentReference.DocumentReferenceContextComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasEvent()) {
- for (CodeableConcept e : element.getEvent())
- composeCodeableConcept("event", e);
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasFacilityType()) {
- composeCodeableConcept("facilityType", element.getFacilityType());
- }
- if (element.hasPracticeSetting()) {
- composeCodeableConcept("practiceSetting", element.getPracticeSetting());
- }
- if (element.hasSourcePatientInfo()) {
- composeReference("sourcePatientInfo", element.getSourcePatientInfo());
- }
- if (element.hasRelated()) {
- for (DocumentReference.DocumentReferenceContextRelatedComponent e : element.getRelated())
- composeDocumentReferenceDocumentReferenceContextRelatedComponent("related", e);
- }
- }
-
- protected void composeDocumentReferenceDocumentReferenceContextRelatedComponent(String name, DocumentReference.DocumentReferenceContextRelatedComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeDocumentReferenceDocumentReferenceContextRelatedComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeDocumentReferenceDocumentReferenceContextRelatedComponentElements(DocumentReference.DocumentReferenceContextRelatedComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasRef()) {
- composeReference("ref", element.getRef());
- }
- }
-
- protected void composeEligibilityRequest(String name, EligibilityRequest element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEligibilityRequestElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEligibilityRequestElements(EligibilityRequest element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasRuleset()) {
- composeCoding("ruleset", element.getRuleset());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasTarget()) {
- composeType("target", element.getTarget());
- } if (element.hasProvider()) {
- composeType("provider", element.getProvider());
- } if (element.hasOrganization()) {
- composeType("organization", element.getOrganization());
- } if (element.hasPriority()) {
- composeCoding("priority", element.getPriority());
- }
- if (element.hasEnterer()) {
- composeType("enterer", element.getEnterer());
- } if (element.hasFacility()) {
- composeType("facility", element.getFacility());
- } if (element.hasPatient()) {
- composeType("patient", element.getPatient());
- } if (element.hasCoverage()) {
- composeType("coverage", element.getCoverage());
- } if (element.hasBusinessArrangementElement()) {
- composeString("businessArrangement", element.getBusinessArrangementElement());
- }
- if (element.hasServiced()) {
- composeType("serviced", element.getServiced());
- } if (element.hasBenefitCategory()) {
- composeCoding("benefitCategory", element.getBenefitCategory());
- }
- if (element.hasBenefitSubCategory()) {
- composeCoding("benefitSubCategory", element.getBenefitSubCategory());
- }
- }
-
- protected void composeEligibilityResponse(String name, EligibilityResponse element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEligibilityResponseElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEligibilityResponseElements(EligibilityResponse element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasRequest()) {
- composeType("request", element.getRequest());
- } if (element.hasOutcomeElement())
- composeEnumeration("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory());
- if (element.hasDispositionElement()) {
- composeString("disposition", element.getDispositionElement());
- }
- if (element.hasRuleset()) {
- composeCoding("ruleset", element.getRuleset());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasOrganization()) {
- composeType("organization", element.getOrganization());
- } if (element.hasRequestProvider()) {
- composeType("requestProvider", element.getRequestProvider());
- } if (element.hasRequestOrganization()) {
- composeType("requestOrganization", element.getRequestOrganization());
- } if (element.hasInforceElement()) {
- composeBoolean("inforce", element.getInforceElement());
- }
- if (element.hasContract()) {
- composeReference("contract", element.getContract());
- }
- if (element.hasForm()) {
- composeCoding("form", element.getForm());
- }
- if (element.hasBenefitBalance()) {
- for (EligibilityResponse.BenefitsComponent e : element.getBenefitBalance())
- composeEligibilityResponseBenefitsComponent("benefitBalance", e);
- }
- if (element.hasError()) {
- for (EligibilityResponse.ErrorsComponent e : element.getError())
- composeEligibilityResponseErrorsComponent("error", e);
- }
- }
-
- protected void composeEligibilityResponseBenefitsComponent(String name, EligibilityResponse.BenefitsComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEligibilityResponseBenefitsComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEligibilityResponseBenefitsComponentElements(EligibilityResponse.BenefitsComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCategory()) {
- composeCoding("category", element.getCategory());
- }
- if (element.hasSubCategory()) {
- composeCoding("subCategory", element.getSubCategory());
- }
- if (element.hasNetwork()) {
- composeCoding("network", element.getNetwork());
- }
- if (element.hasUnit()) {
- composeCoding("unit", element.getUnit());
- }
- if (element.hasTerm()) {
- composeCoding("term", element.getTerm());
- }
- if (element.hasFinancial()) {
- for (EligibilityResponse.BenefitComponent e : element.getFinancial())
- composeEligibilityResponseBenefitComponent("financial", e);
- }
- }
-
- protected void composeEligibilityResponseBenefitComponent(String name, EligibilityResponse.BenefitComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEligibilityResponseBenefitComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEligibilityResponseBenefitComponentElements(EligibilityResponse.BenefitComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasBenefit()) {
- composeType("benefit", element.getBenefit());
- } if (element.hasBenefitUsed()) {
- composeType("benefitUsed", element.getBenefitUsed());
- } }
-
- protected void composeEligibilityResponseErrorsComponent(String name, EligibilityResponse.ErrorsComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEligibilityResponseErrorsComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEligibilityResponseErrorsComponentElements(EligibilityResponse.ErrorsComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- composeCoding("code", element.getCode());
- }
- }
-
- protected void composeEncounter(String name, Encounter element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEncounterElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEncounterElements(Encounter element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Encounter.EncounterStateEnumFactory());
- if (element.hasStatusHistory()) {
- for (Encounter.EncounterStatusHistoryComponent e : element.getStatusHistory())
- composeEncounterEncounterStatusHistoryComponent("statusHistory", e);
- }
- if (element.hasClass_Element())
- composeEnumeration("class", element.getClass_Element(), new Encounter.EncounterClassEnumFactory());
- if (element.hasType()) {
- for (CodeableConcept e : element.getType())
- composeCodeableConcept("type", e);
- }
- if (element.hasPriority()) {
- composeCodeableConcept("priority", element.getPriority());
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasEpisodeOfCare()) {
- for (Reference e : element.getEpisodeOfCare())
- composeReference("episodeOfCare", e);
- }
- if (element.hasIncomingReferral()) {
- for (Reference e : element.getIncomingReferral())
- composeReference("incomingReferral", e);
- }
- if (element.hasParticipant()) {
- for (Encounter.EncounterParticipantComponent e : element.getParticipant())
- composeEncounterEncounterParticipantComponent("participant", e);
- }
- if (element.hasAppointment()) {
- composeReference("appointment", element.getAppointment());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasLength()) {
- composeDuration("length", element.getLength());
- }
- if (element.hasReason()) {
- for (CodeableConcept e : element.getReason())
- composeCodeableConcept("reason", e);
- }
- if (element.hasIndication()) {
- for (Reference e : element.getIndication())
- composeReference("indication", e);
- }
- if (element.hasHospitalization()) {
- composeEncounterEncounterHospitalizationComponent("hospitalization", element.getHospitalization());
- }
- if (element.hasLocation()) {
- for (Encounter.EncounterLocationComponent e : element.getLocation())
- composeEncounterEncounterLocationComponent("location", e);
- }
- if (element.hasServiceProvider()) {
- composeReference("serviceProvider", element.getServiceProvider());
- }
- if (element.hasPartOf()) {
- composeReference("partOf", element.getPartOf());
- }
- }
-
- protected void composeEncounterEncounterStatusHistoryComponent(String name, Encounter.EncounterStatusHistoryComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEncounterEncounterStatusHistoryComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEncounterEncounterStatusHistoryComponentElements(Encounter.EncounterStatusHistoryComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Encounter.EncounterStateEnumFactory());
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composeEncounterEncounterParticipantComponent(String name, Encounter.EncounterParticipantComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEncounterEncounterParticipantComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEncounterEncounterParticipantComponentElements(Encounter.EncounterParticipantComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- for (CodeableConcept e : element.getType())
- composeCodeableConcept("type", e);
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasIndividual()) {
- composeReference("individual", element.getIndividual());
- }
- }
-
- protected void composeEncounterEncounterHospitalizationComponent(String name, Encounter.EncounterHospitalizationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEncounterEncounterHospitalizationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEncounterEncounterHospitalizationComponentElements(Encounter.EncounterHospitalizationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasPreAdmissionIdentifier()) {
- composeIdentifier("preAdmissionIdentifier", element.getPreAdmissionIdentifier());
- }
- if (element.hasOrigin()) {
- composeReference("origin", element.getOrigin());
- }
- if (element.hasAdmitSource()) {
- composeCodeableConcept("admitSource", element.getAdmitSource());
- }
- if (element.hasAdmittingDiagnosis()) {
- for (Reference e : element.getAdmittingDiagnosis())
- composeReference("admittingDiagnosis", e);
- }
- if (element.hasReAdmission()) {
- composeCodeableConcept("reAdmission", element.getReAdmission());
- }
- if (element.hasDietPreference()) {
- for (CodeableConcept e : element.getDietPreference())
- composeCodeableConcept("dietPreference", e);
- }
- if (element.hasSpecialCourtesy()) {
- for (CodeableConcept e : element.getSpecialCourtesy())
- composeCodeableConcept("specialCourtesy", e);
- }
- if (element.hasSpecialArrangement()) {
- for (CodeableConcept e : element.getSpecialArrangement())
- composeCodeableConcept("specialArrangement", e);
- }
- if (element.hasDestination()) {
- composeReference("destination", element.getDestination());
- }
- if (element.hasDischargeDisposition()) {
- composeCodeableConcept("dischargeDisposition", element.getDischargeDisposition());
- }
- if (element.hasDischargeDiagnosis()) {
- for (Reference e : element.getDischargeDiagnosis())
- composeReference("dischargeDiagnosis", e);
- }
- }
-
- protected void composeEncounterEncounterLocationComponent(String name, Encounter.EncounterLocationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEncounterEncounterLocationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEncounterEncounterLocationComponentElements(Encounter.EncounterLocationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLocation()) {
- composeReference("location", element.getLocation());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Encounter.EncounterLocationStatusEnumFactory());
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composeEndpoint(String name, Endpoint element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEndpointElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEndpointElements(Endpoint element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Endpoint.EndpointStatusEnumFactory());
- if (element.hasManagingOrganization()) {
- composeReference("managingOrganization", element.getManagingOrganization());
- }
- if (element.hasContact()) {
- for (ContactPoint e : element.getContact())
- composeContactPoint("contact", e);
- }
- if (element.hasConnectionTypeElement()) {
- composeCode("connectionType", element.getConnectionTypeElement());
- }
- if (element.hasMethod()) {
- for (Coding e : element.getMethod())
- composeCoding("method", e);
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasAddress()) {
- composeType("address", element.getAddress());
- } if (element.hasPayloadFormatElement()) {
- composeString("payloadFormat", element.getPayloadFormatElement());
- }
- if (element.hasPayloadType()) {
- for (CodeableConcept e : element.getPayloadType())
- composeCodeableConcept("payloadType", e);
- }
- if (element.hasHeader()) {
- for (StringType e : element.getHeader())
- composeString("header", e);
- }
- if (element.hasPublicKeyElement()) {
- composeString("publicKey", element.getPublicKeyElement());
- }
- }
-
- protected void composeEnrollmentRequest(String name, EnrollmentRequest element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEnrollmentRequestElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEnrollmentRequestElements(EnrollmentRequest element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasRuleset()) {
- composeCoding("ruleset", element.getRuleset());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasTarget()) {
- composeReference("target", element.getTarget());
- }
- if (element.hasProvider()) {
- composeReference("provider", element.getProvider());
- }
- if (element.hasOrganization()) {
- composeReference("organization", element.getOrganization());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasCoverage()) {
- composeReference("coverage", element.getCoverage());
- }
- if (element.hasRelationship()) {
- composeCoding("relationship", element.getRelationship());
- }
- }
-
- protected void composeEnrollmentResponse(String name, EnrollmentResponse element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEnrollmentResponseElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEnrollmentResponseElements(EnrollmentResponse element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasRequest()) {
- composeReference("request", element.getRequest());
- }
- if (element.hasOutcomeElement())
- composeEnumeration("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory());
- if (element.hasDispositionElement()) {
- composeString("disposition", element.getDispositionElement());
- }
- if (element.hasRuleset()) {
- composeCoding("ruleset", element.getRuleset());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasOrganization()) {
- composeReference("organization", element.getOrganization());
- }
- if (element.hasRequestProvider()) {
- composeReference("requestProvider", element.getRequestProvider());
- }
- if (element.hasRequestOrganization()) {
- composeReference("requestOrganization", element.getRequestOrganization());
- }
- }
-
- protected void composeEpisodeOfCare(String name, EpisodeOfCare element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEpisodeOfCareElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEpisodeOfCareElements(EpisodeOfCare element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new EpisodeOfCare.EpisodeOfCareStatusEnumFactory());
- if (element.hasStatusHistory()) {
- for (EpisodeOfCare.EpisodeOfCareStatusHistoryComponent e : element.getStatusHistory())
- composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent("statusHistory", e);
- }
- if (element.hasType()) {
- for (CodeableConcept e : element.getType())
- composeCodeableConcept("type", e);
- }
- if (element.hasCondition()) {
- for (Reference e : element.getCondition())
- composeReference("condition", e);
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasManagingOrganization()) {
- composeReference("managingOrganization", element.getManagingOrganization());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasReferralRequest()) {
- for (Reference e : element.getReferralRequest())
- composeReference("referralRequest", e);
- }
- if (element.hasCareManager()) {
- composeReference("careManager", element.getCareManager());
- }
- if (element.hasTeam()) {
- for (Reference e : element.getTeam())
- composeReference("team", e);
- }
- }
-
- protected void composeEpisodeOfCareEpisodeOfCareStatusHistoryComponent(String name, EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeEpisodeOfCareEpisodeOfCareStatusHistoryComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeEpisodeOfCareEpisodeOfCareStatusHistoryComponentElements(EpisodeOfCare.EpisodeOfCareStatusHistoryComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new EpisodeOfCare.EpisodeOfCareStatusEnumFactory());
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composeExpansionProfile(String name, ExpansionProfile element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileElements(ExpansionProfile element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (ExpansionProfile.ExpansionProfileContactComponent e : element.getContact())
- composeExpansionProfileExpansionProfileContactComponent("contact", e);
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasCodeSystem()) {
- composeExpansionProfileExpansionProfileCodeSystemComponent("codeSystem", element.getCodeSystem());
- }
- if (element.hasIncludeDesignationsElement()) {
- composeBoolean("includeDesignations", element.getIncludeDesignationsElement());
- }
- if (element.hasDesignation()) {
- composeExpansionProfileExpansionProfileDesignationComponent("designation", element.getDesignation());
- }
- if (element.hasIncludeDefinitionElement()) {
- composeBoolean("includeDefinition", element.getIncludeDefinitionElement());
- }
- if (element.hasIncludeInactiveElement()) {
- composeBoolean("includeInactive", element.getIncludeInactiveElement());
- }
- if (element.hasExcludeNestedElement()) {
- composeBoolean("excludeNested", element.getExcludeNestedElement());
- }
- if (element.hasExcludeNotForUIElement()) {
- composeBoolean("excludeNotForUI", element.getExcludeNotForUIElement());
- }
- if (element.hasExcludePostCoordinatedElement()) {
- composeBoolean("excludePostCoordinated", element.getExcludePostCoordinatedElement());
- }
- if (element.hasDisplayLanguageElement()) {
- composeCode("displayLanguage", element.getDisplayLanguageElement());
- }
- if (element.hasLimitedExpansionElement()) {
- composeBoolean("limitedExpansion", element.getLimitedExpansionElement());
- }
- }
-
- protected void composeExpansionProfileExpansionProfileContactComponent(String name, ExpansionProfile.ExpansionProfileContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileExpansionProfileContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileExpansionProfileContactComponentElements(ExpansionProfile.ExpansionProfileContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeExpansionProfileExpansionProfileCodeSystemComponent(String name, ExpansionProfile.ExpansionProfileCodeSystemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileExpansionProfileCodeSystemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileExpansionProfileCodeSystemComponentElements(ExpansionProfile.ExpansionProfileCodeSystemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasInclude()) {
- composeExpansionProfileCodeSystemIncludeComponent("include", element.getInclude());
- }
- if (element.hasExclude()) {
- composeExpansionProfileCodeSystemExcludeComponent("exclude", element.getExclude());
- }
- }
-
- protected void composeExpansionProfileCodeSystemIncludeComponent(String name, ExpansionProfile.CodeSystemIncludeComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileCodeSystemIncludeComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileCodeSystemIncludeComponentElements(ExpansionProfile.CodeSystemIncludeComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeSystem()) {
- for (ExpansionProfile.CodeSystemIncludeCodeSystemComponent e : element.getCodeSystem())
- composeExpansionProfileCodeSystemIncludeCodeSystemComponent("codeSystem", e);
- }
- }
-
- protected void composeExpansionProfileCodeSystemIncludeCodeSystemComponent(String name, ExpansionProfile.CodeSystemIncludeCodeSystemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileCodeSystemIncludeCodeSystemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileCodeSystemIncludeCodeSystemComponentElements(ExpansionProfile.CodeSystemIncludeCodeSystemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSystemElement()) {
- composeUri("system", element.getSystemElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- }
-
- protected void composeExpansionProfileCodeSystemExcludeComponent(String name, ExpansionProfile.CodeSystemExcludeComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileCodeSystemExcludeComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileCodeSystemExcludeComponentElements(ExpansionProfile.CodeSystemExcludeComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeSystem()) {
- for (ExpansionProfile.CodeSystemExcludeCodeSystemComponent e : element.getCodeSystem())
- composeExpansionProfileCodeSystemExcludeCodeSystemComponent("codeSystem", e);
- }
- }
-
- protected void composeExpansionProfileCodeSystemExcludeCodeSystemComponent(String name, ExpansionProfile.CodeSystemExcludeCodeSystemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileCodeSystemExcludeCodeSystemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileCodeSystemExcludeCodeSystemComponentElements(ExpansionProfile.CodeSystemExcludeCodeSystemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSystemElement()) {
- composeUri("system", element.getSystemElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- }
-
- protected void composeExpansionProfileExpansionProfileDesignationComponent(String name, ExpansionProfile.ExpansionProfileDesignationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileExpansionProfileDesignationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileExpansionProfileDesignationComponentElements(ExpansionProfile.ExpansionProfileDesignationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasInclude()) {
- composeExpansionProfileDesignationIncludeComponent("include", element.getInclude());
- }
- if (element.hasExclude()) {
- composeExpansionProfileDesignationExcludeComponent("exclude", element.getExclude());
- }
- }
-
- protected void composeExpansionProfileDesignationIncludeComponent(String name, ExpansionProfile.DesignationIncludeComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileDesignationIncludeComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileDesignationIncludeComponentElements(ExpansionProfile.DesignationIncludeComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDesignation()) {
- for (ExpansionProfile.DesignationIncludeDesignationComponent e : element.getDesignation())
- composeExpansionProfileDesignationIncludeDesignationComponent("designation", e);
- }
- }
-
- protected void composeExpansionProfileDesignationIncludeDesignationComponent(String name, ExpansionProfile.DesignationIncludeDesignationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileDesignationIncludeDesignationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileDesignationIncludeDesignationComponentElements(ExpansionProfile.DesignationIncludeDesignationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLanguageElement()) {
- composeCode("language", element.getLanguageElement());
- }
- if (element.hasUse()) {
- composeCoding("use", element.getUse());
- }
- }
-
- protected void composeExpansionProfileDesignationExcludeComponent(String name, ExpansionProfile.DesignationExcludeComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileDesignationExcludeComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileDesignationExcludeComponentElements(ExpansionProfile.DesignationExcludeComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDesignation()) {
- for (ExpansionProfile.DesignationExcludeDesignationComponent e : element.getDesignation())
- composeExpansionProfileDesignationExcludeDesignationComponent("designation", e);
- }
- }
-
- protected void composeExpansionProfileDesignationExcludeDesignationComponent(String name, ExpansionProfile.DesignationExcludeDesignationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExpansionProfileDesignationExcludeDesignationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExpansionProfileDesignationExcludeDesignationComponentElements(ExpansionProfile.DesignationExcludeDesignationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLanguageElement()) {
- composeCode("language", element.getLanguageElement());
- }
- if (element.hasUse()) {
- composeCoding("use", element.getUse());
- }
- }
-
- protected void composeExplanationOfBenefit(String name, ExplanationOfBenefit element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitElements(ExplanationOfBenefit element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasClaim()) {
- composeType("claim", element.getClaim());
- } if (element.hasClaimResponse()) {
- composeType("claimResponse", element.getClaimResponse());
- } if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new ExplanationOfBenefit.ClaimType2EnumFactory());
- if (element.hasSubType()) {
- for (Coding e : element.getSubType())
- composeCoding("subType", e);
- }
- if (element.hasRuleset()) {
- composeCoding("ruleset", element.getRuleset());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasBillablePeriod()) {
- composePeriod("billablePeriod", element.getBillablePeriod());
- }
- if (element.hasDispositionElement()) {
- composeString("disposition", element.getDispositionElement());
- }
- if (element.hasProvider()) {
- composeType("provider", element.getProvider());
- } if (element.hasOrganization()) {
- composeType("organization", element.getOrganization());
- } if (element.hasFacility()) {
- composeType("facility", element.getFacility());
- } if (element.hasRelated()) {
- for (ExplanationOfBenefit.RelatedClaimComponent e : element.getRelated())
- composeExplanationOfBenefitRelatedClaimComponent("related", e);
- }
- if (element.hasPrescription()) {
- composeType("prescription", element.getPrescription());
- } if (element.hasOriginalPrescription()) {
- composeType("originalPrescription", element.getOriginalPrescription());
- } if (element.hasPayee()) {
- composeExplanationOfBenefitPayeeComponent("payee", element.getPayee());
- }
- if (element.hasReferral()) {
- composeType("referral", element.getReferral());
- } if (element.hasInformation()) {
- for (ExplanationOfBenefit.InformationComponent e : element.getInformation())
- composeExplanationOfBenefitInformationComponent("information", e);
- }
- if (element.hasDiagnosis()) {
- for (ExplanationOfBenefit.DiagnosisComponent e : element.getDiagnosis())
- composeExplanationOfBenefitDiagnosisComponent("diagnosis", e);
- }
- if (element.hasProcedure()) {
- for (ExplanationOfBenefit.ProcedureComponent e : element.getProcedure())
- composeExplanationOfBenefitProcedureComponent("procedure", e);
- }
- if (element.hasPatient()) {
- composeType("patient", element.getPatient());
- } if (element.hasPrecedenceElement()) {
- composePositiveInt("precedence", element.getPrecedenceElement());
- }
- if (element.hasCoverage()) {
- composeExplanationOfBenefitCoverageComponent("coverage", element.getCoverage());
- }
- if (element.hasItem()) {
- for (ExplanationOfBenefit.ItemComponent e : element.getItem())
- composeExplanationOfBenefitItemComponent("item", e);
- }
- if (element.hasAddItem()) {
- for (ExplanationOfBenefit.AddedItemComponent e : element.getAddItem())
- composeExplanationOfBenefitAddedItemComponent("addItem", e);
- }
- if (element.hasTotalCost()) {
- composeMoney("totalCost", element.getTotalCost());
- }
- if (element.hasUnallocDeductable()) {
- composeMoney("unallocDeductable", element.getUnallocDeductable());
- }
- if (element.hasTotalBenefit()) {
- composeMoney("totalBenefit", element.getTotalBenefit());
- }
- if (element.hasPaymentAdjustment()) {
- composeMoney("paymentAdjustment", element.getPaymentAdjustment());
- }
- if (element.hasPaymentAdjustmentReason()) {
- composeCoding("paymentAdjustmentReason", element.getPaymentAdjustmentReason());
- }
- if (element.hasPaymentDateElement()) {
- composeDate("paymentDate", element.getPaymentDateElement());
- }
- if (element.hasPaymentAmount()) {
- composeMoney("paymentAmount", element.getPaymentAmount());
- }
- if (element.hasPaymentRef()) {
- composeIdentifier("paymentRef", element.getPaymentRef());
- }
- if (element.hasReserved()) {
- composeCoding("reserved", element.getReserved());
- }
- if (element.hasForm()) {
- composeCoding("form", element.getForm());
- }
- if (element.hasNote()) {
- for (ExplanationOfBenefit.NoteComponent e : element.getNote())
- composeExplanationOfBenefitNoteComponent("note", e);
- }
- if (element.hasBenefitBalance()) {
- for (ExplanationOfBenefit.BenefitBalanceComponent e : element.getBenefitBalance())
- composeExplanationOfBenefitBenefitBalanceComponent("benefitBalance", e);
- }
- }
-
- protected void composeExplanationOfBenefitRelatedClaimComponent(String name, ExplanationOfBenefit.RelatedClaimComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitRelatedClaimComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitRelatedClaimComponentElements(ExplanationOfBenefit.RelatedClaimComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasClaim()) {
- composeType("claim", element.getClaim());
- } if (element.hasRelationship()) {
- composeCoding("relationship", element.getRelationship());
- }
- if (element.hasReference()) {
- composeIdentifier("reference", element.getReference());
- }
- }
-
- protected void composeExplanationOfBenefitPayeeComponent(String name, ExplanationOfBenefit.PayeeComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitPayeeComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitPayeeComponentElements(ExplanationOfBenefit.PayeeComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasParty()) {
- composeType("party", element.getParty());
- } }
-
- protected void composeExplanationOfBenefitInformationComponent(String name, ExplanationOfBenefit.InformationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitInformationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitInformationComponentElements(ExplanationOfBenefit.InformationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCategory()) {
- composeCoding("category", element.getCategory());
- }
- if (element.hasCode()) {
- composeCoding("code", element.getCode());
- }
- if (element.hasReason()) {
- composeCoding("reason", element.getReason());
- }
- if (element.hasTiming()) {
- composeType("timing", element.getTiming());
- } if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeExplanationOfBenefitDiagnosisComponent(String name, ExplanationOfBenefit.DiagnosisComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitDiagnosisComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitDiagnosisComponentElements(ExplanationOfBenefit.DiagnosisComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasDiagnosis()) {
- composeCoding("diagnosis", element.getDiagnosis());
- }
- }
-
- protected void composeExplanationOfBenefitProcedureComponent(String name, ExplanationOfBenefit.ProcedureComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitProcedureComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitProcedureComponentElements(ExplanationOfBenefit.ProcedureComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasProcedure()) {
- composeType("procedure", element.getProcedure());
- } }
-
- protected void composeExplanationOfBenefitCoverageComponent(String name, ExplanationOfBenefit.CoverageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitCoverageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitCoverageComponentElements(ExplanationOfBenefit.CoverageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCoverage()) {
- composeType("coverage", element.getCoverage());
- } if (element.hasPreAuthRef()) {
- for (StringType e : element.getPreAuthRef())
- composeString("preAuthRef", e);
- }
- }
-
- protected void composeExplanationOfBenefitItemComponent(String name, ExplanationOfBenefit.ItemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitItemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitItemComponentElements(ExplanationOfBenefit.ItemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasCareTeam()) {
- for (ExplanationOfBenefit.CareTeamComponent e : element.getCareTeam())
- composeExplanationOfBenefitCareTeamComponent("careTeam", e);
- }
- if (element.hasDiagnosisLinkId()) {
- for (PositiveIntType e : element.getDiagnosisLinkId())
- composePositiveInt("diagnosisLinkId", e);
- }
- if (element.hasService()) {
- composeCoding("service", element.getService());
- }
- if (element.hasServiceModifier()) {
- for (Coding e : element.getServiceModifier())
- composeCoding("serviceModifier", e);
- }
- if (element.hasModifier()) {
- for (Coding e : element.getModifier())
- composeCoding("modifier", e);
- }
- if (element.hasProgramCode()) {
- for (Coding e : element.getProgramCode())
- composeCoding("programCode", e);
- }
- if (element.hasServiced()) {
- composeType("serviced", element.getServiced());
- } if (element.hasPlace()) {
- composeCoding("place", element.getPlace());
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasUnitPrice()) {
- composeMoney("unitPrice", element.getUnitPrice());
- }
- if (element.hasFactorElement()) {
- composeDecimal("factor", element.getFactorElement());
- }
- if (element.hasPointsElement()) {
- composeDecimal("points", element.getPointsElement());
- }
- if (element.hasNet()) {
- composeMoney("net", element.getNet());
- }
- if (element.hasUdi()) {
- for (Reference e : element.getUdi())
- composeReference("udi", e);
- }
- if (element.hasBodySite()) {
- composeCoding("bodySite", element.getBodySite());
- }
- if (element.hasSubSite()) {
- for (Coding e : element.getSubSite())
- composeCoding("subSite", e);
- }
- if (element.hasNoteNumber()) {
- for (PositiveIntType e : element.getNoteNumber())
- composePositiveInt("noteNumber", e);
- }
- if (element.hasAdjudication()) {
- for (ExplanationOfBenefit.AdjudicationComponent e : element.getAdjudication())
- composeExplanationOfBenefitAdjudicationComponent("adjudication", e);
- }
- if (element.hasDetail()) {
- for (ExplanationOfBenefit.DetailComponent e : element.getDetail())
- composeExplanationOfBenefitDetailComponent("detail", e);
- }
- if (element.hasProsthesis()) {
- composeExplanationOfBenefitProsthesisComponent("prosthesis", element.getProsthesis());
- }
- }
-
- protected void composeExplanationOfBenefitCareTeamComponent(String name, ExplanationOfBenefit.CareTeamComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitCareTeamComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitCareTeamComponentElements(ExplanationOfBenefit.CareTeamComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasProvider()) {
- composeType("provider", element.getProvider());
- } if (element.hasResponsibleElement()) {
- composeBoolean("responsible", element.getResponsibleElement());
- }
- if (element.hasRole()) {
- composeCoding("role", element.getRole());
- }
- if (element.hasQualification()) {
- composeCoding("qualification", element.getQualification());
- }
- }
-
- protected void composeExplanationOfBenefitAdjudicationComponent(String name, ExplanationOfBenefit.AdjudicationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitAdjudicationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitAdjudicationComponentElements(ExplanationOfBenefit.AdjudicationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCategory()) {
- composeCoding("category", element.getCategory());
- }
- if (element.hasReason()) {
- composeCoding("reason", element.getReason());
- }
- if (element.hasAmount()) {
- composeMoney("amount", element.getAmount());
- }
- if (element.hasValueElement()) {
- composeDecimal("value", element.getValueElement());
- }
- }
-
- protected void composeExplanationOfBenefitDetailComponent(String name, ExplanationOfBenefit.DetailComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitDetailComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitDetailComponentElements(ExplanationOfBenefit.DetailComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasService()) {
- composeCoding("service", element.getService());
- }
- if (element.hasProgramCode()) {
- for (Coding e : element.getProgramCode())
- composeCoding("programCode", e);
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasUnitPrice()) {
- composeMoney("unitPrice", element.getUnitPrice());
- }
- if (element.hasFactorElement()) {
- composeDecimal("factor", element.getFactorElement());
- }
- if (element.hasPointsElement()) {
- composeDecimal("points", element.getPointsElement());
- }
- if (element.hasNet()) {
- composeMoney("net", element.getNet());
- }
- if (element.hasUdi()) {
- for (Reference e : element.getUdi())
- composeReference("udi", e);
- }
- if (element.hasAdjudication()) {
- for (ExplanationOfBenefit.AdjudicationComponent e : element.getAdjudication())
- composeExplanationOfBenefitAdjudicationComponent("adjudication", e);
- }
- if (element.hasSubDetail()) {
- for (ExplanationOfBenefit.SubDetailComponent e : element.getSubDetail())
- composeExplanationOfBenefitSubDetailComponent("subDetail", e);
- }
- }
-
- protected void composeExplanationOfBenefitSubDetailComponent(String name, ExplanationOfBenefit.SubDetailComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitSubDetailComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitSubDetailComponentElements(ExplanationOfBenefit.SubDetailComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composePositiveInt("sequence", element.getSequenceElement());
- }
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasService()) {
- composeCoding("service", element.getService());
- }
- if (element.hasProgramCode()) {
- for (Coding e : element.getProgramCode())
- composeCoding("programCode", e);
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasUnitPrice()) {
- composeMoney("unitPrice", element.getUnitPrice());
- }
- if (element.hasFactorElement()) {
- composeDecimal("factor", element.getFactorElement());
- }
- if (element.hasPointsElement()) {
- composeDecimal("points", element.getPointsElement());
- }
- if (element.hasNet()) {
- composeMoney("net", element.getNet());
- }
- if (element.hasUdi()) {
- for (Reference e : element.getUdi())
- composeReference("udi", e);
- }
- if (element.hasAdjudication()) {
- for (ExplanationOfBenefit.AdjudicationComponent e : element.getAdjudication())
- composeExplanationOfBenefitAdjudicationComponent("adjudication", e);
- }
- }
-
- protected void composeExplanationOfBenefitProsthesisComponent(String name, ExplanationOfBenefit.ProsthesisComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitProsthesisComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitProsthesisComponentElements(ExplanationOfBenefit.ProsthesisComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasInitialElement()) {
- composeBoolean("initial", element.getInitialElement());
- }
- if (element.hasPriorDateElement()) {
- composeDate("priorDate", element.getPriorDateElement());
- }
- if (element.hasPriorMaterial()) {
- composeCoding("priorMaterial", element.getPriorMaterial());
- }
- }
-
- protected void composeExplanationOfBenefitAddedItemComponent(String name, ExplanationOfBenefit.AddedItemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitAddedItemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitAddedItemComponentElements(ExplanationOfBenefit.AddedItemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceLinkId()) {
- for (PositiveIntType e : element.getSequenceLinkId())
- composePositiveInt("sequenceLinkId", e);
- }
- if (element.hasService()) {
- composeCoding("service", element.getService());
- }
- if (element.hasFee()) {
- composeMoney("fee", element.getFee());
- }
- if (element.hasNoteNumberLinkId()) {
- for (PositiveIntType e : element.getNoteNumberLinkId())
- composePositiveInt("noteNumberLinkId", e);
- }
- if (element.hasAdjudication()) {
- for (ExplanationOfBenefit.AdjudicationComponent e : element.getAdjudication())
- composeExplanationOfBenefitAdjudicationComponent("adjudication", e);
- }
- if (element.hasDetail()) {
- for (ExplanationOfBenefit.AddedItemsDetailComponent e : element.getDetail())
- composeExplanationOfBenefitAddedItemsDetailComponent("detail", e);
- }
- }
-
- protected void composeExplanationOfBenefitAddedItemsDetailComponent(String name, ExplanationOfBenefit.AddedItemsDetailComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitAddedItemsDetailComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitAddedItemsDetailComponentElements(ExplanationOfBenefit.AddedItemsDetailComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasService()) {
- composeCoding("service", element.getService());
- }
- if (element.hasFee()) {
- composeMoney("fee", element.getFee());
- }
- if (element.hasAdjudication()) {
- for (ExplanationOfBenefit.AdjudicationComponent e : element.getAdjudication())
- composeExplanationOfBenefitAdjudicationComponent("adjudication", e);
- }
- }
-
- protected void composeExplanationOfBenefitNoteComponent(String name, ExplanationOfBenefit.NoteComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitNoteComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitNoteComponentElements(ExplanationOfBenefit.NoteComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNumberElement()) {
- composePositiveInt("number", element.getNumberElement());
- }
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- }
-
- protected void composeExplanationOfBenefitBenefitBalanceComponent(String name, ExplanationOfBenefit.BenefitBalanceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitBenefitBalanceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitBenefitBalanceComponentElements(ExplanationOfBenefit.BenefitBalanceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCategory()) {
- composeCoding("category", element.getCategory());
- }
- if (element.hasSubCategory()) {
- composeCoding("subCategory", element.getSubCategory());
- }
- if (element.hasNetwork()) {
- composeCoding("network", element.getNetwork());
- }
- if (element.hasUnit()) {
- composeCoding("unit", element.getUnit());
- }
- if (element.hasTerm()) {
- composeCoding("term", element.getTerm());
- }
- if (element.hasFinancial()) {
- for (ExplanationOfBenefit.BenefitComponent e : element.getFinancial())
- composeExplanationOfBenefitBenefitComponent("financial", e);
- }
- }
-
- protected void composeExplanationOfBenefitBenefitComponent(String name, ExplanationOfBenefit.BenefitComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeExplanationOfBenefitBenefitComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeExplanationOfBenefitBenefitComponentElements(ExplanationOfBenefit.BenefitComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasBenefit()) {
- composeType("benefit", element.getBenefit());
- } if (element.hasBenefitUsed()) {
- composeType("benefitUsed", element.getBenefitUsed());
- } }
-
- protected void composeFamilyMemberHistory(String name, FamilyMemberHistory element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeFamilyMemberHistoryElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeFamilyMemberHistoryElements(FamilyMemberHistory element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new FamilyMemberHistory.FamilyHistoryStatusEnumFactory());
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasRelationship()) {
- composeCodeableConcept("relationship", element.getRelationship());
- }
- if (element.hasGenderElement())
- composeEnumeration("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory());
- if (element.hasBorn()) {
- composeType("born", element.getBorn());
- } if (element.hasAge()) {
- composeType("age", element.getAge());
- } if (element.hasDeceased()) {
- composeType("deceased", element.getDeceased());
- } if (element.hasNote()) {
- composeAnnotation("note", element.getNote());
- }
- if (element.hasCondition()) {
- for (FamilyMemberHistory.FamilyMemberHistoryConditionComponent e : element.getCondition())
- composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent("condition", e);
- }
- }
-
- protected void composeFamilyMemberHistoryFamilyMemberHistoryConditionComponent(String name, FamilyMemberHistory.FamilyMemberHistoryConditionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeFamilyMemberHistoryFamilyMemberHistoryConditionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeFamilyMemberHistoryFamilyMemberHistoryConditionComponentElements(FamilyMemberHistory.FamilyMemberHistoryConditionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasOutcome()) {
- composeCodeableConcept("outcome", element.getOutcome());
- }
- if (element.hasOnset()) {
- composeType("onset", element.getOnset());
- } if (element.hasNote()) {
- composeAnnotation("note", element.getNote());
- }
- }
-
- protected void composeFlag(String name, Flag element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeFlagElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeFlagElements(Flag element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasCategory()) {
- composeCodeableConcept("category", element.getCategory());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Flag.FlagStatusEnumFactory());
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasAuthor()) {
- composeReference("author", element.getAuthor());
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- }
-
- protected void composeGoal(String name, Goal element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeGoalElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeGoalElements(Goal element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasStart()) {
- composeType("start", element.getStart());
- } if (element.hasTarget()) {
- composeType("target", element.getTarget());
- } if (element.hasCategory()) {
- for (CodeableConcept e : element.getCategory())
- composeCodeableConcept("category", e);
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Goal.GoalStatusEnumFactory());
- if (element.hasStatusDateElement()) {
- composeDate("statusDate", element.getStatusDateElement());
- }
- if (element.hasStatusReason()) {
- composeCodeableConcept("statusReason", element.getStatusReason());
- }
- if (element.hasExpressedBy()) {
- composeReference("expressedBy", element.getExpressedBy());
- }
- if (element.hasPriority()) {
- composeCodeableConcept("priority", element.getPriority());
- }
- if (element.hasAddresses()) {
- for (Reference e : element.getAddresses())
- composeReference("addresses", e);
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- if (element.hasOutcome()) {
- for (Goal.GoalOutcomeComponent e : element.getOutcome())
- composeGoalGoalOutcomeComponent("outcome", e);
- }
- }
-
- protected void composeGoalGoalOutcomeComponent(String name, Goal.GoalOutcomeComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeGoalGoalOutcomeComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeGoalGoalOutcomeComponentElements(Goal.GoalOutcomeComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasResult()) {
- composeType("result", element.getResult());
- } }
-
- protected void composeGroup(String name, Group element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeGroupElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeGroupElements(Group element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Group.GroupTypeEnumFactory());
- if (element.hasActualElement()) {
- composeBoolean("actual", element.getActualElement());
- }
- if (element.hasActiveElement()) {
- composeBoolean("active", element.getActiveElement());
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasQuantityElement()) {
- composeUnsignedInt("quantity", element.getQuantityElement());
- }
- if (element.hasCharacteristic()) {
- for (Group.GroupCharacteristicComponent e : element.getCharacteristic())
- composeGroupGroupCharacteristicComponent("characteristic", e);
- }
- if (element.hasMember()) {
- for (Group.GroupMemberComponent e : element.getMember())
- composeGroupGroupMemberComponent("member", e);
- }
- }
-
- protected void composeGroupGroupCharacteristicComponent(String name, Group.GroupCharacteristicComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeGroupGroupCharacteristicComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeGroupGroupCharacteristicComponentElements(Group.GroupCharacteristicComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } if (element.hasExcludeElement()) {
- composeBoolean("exclude", element.getExcludeElement());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composeGroupGroupMemberComponent(String name, Group.GroupMemberComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeGroupGroupMemberComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeGroupGroupMemberComponentElements(Group.GroupMemberComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasEntity()) {
- composeReference("entity", element.getEntity());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasInactiveElement()) {
- composeBoolean("inactive", element.getInactiveElement());
- }
- }
-
- protected void composeGuidanceResponse(String name, GuidanceResponse element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeGuidanceResponseElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeGuidanceResponseElements(GuidanceResponse element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasRequestIdElement()) {
- composeString("requestId", element.getRequestIdElement());
- }
- if (element.hasModule()) {
- composeReference("module", element.getModule());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new GuidanceResponse.GuidanceResponseStatusEnumFactory());
- if (element.hasEvaluationMessage()) {
- for (Reference e : element.getEvaluationMessage())
- composeReference("evaluationMessage", e);
- }
- if (element.hasOutputParameters()) {
- composeReference("outputParameters", element.getOutputParameters());
- }
- if (element.hasAction()) {
- for (GuidanceResponse.GuidanceResponseActionComponent e : element.getAction())
- composeGuidanceResponseGuidanceResponseActionComponent("action", e);
- }
- if (element.hasDataRequirement()) {
- for (DataRequirement e : element.getDataRequirement())
- composeDataRequirement("dataRequirement", e);
- }
- }
-
- protected void composeGuidanceResponseGuidanceResponseActionComponent(String name, GuidanceResponse.GuidanceResponseActionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeGuidanceResponseGuidanceResponseActionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeGuidanceResponseGuidanceResponseActionComponentElements(GuidanceResponse.GuidanceResponseActionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasActionIdentifier()) {
- composeIdentifier("actionIdentifier", element.getActionIdentifier());
- }
- if (element.hasLabelElement()) {
- composeString("label", element.getLabelElement());
- }
- if (element.hasTitleElement()) {
- composeString("title", element.getTitleElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasTextEquivalentElement()) {
- composeString("textEquivalent", element.getTextEquivalentElement());
- }
- if (element.hasConcept()) {
- for (CodeableConcept e : element.getConcept())
- composeCodeableConcept("concept", e);
- }
- if (element.hasSupportingEvidence()) {
- for (Attachment e : element.getSupportingEvidence())
- composeAttachment("supportingEvidence", e);
- }
- if (element.hasRelatedAction()) {
- composeGuidanceResponseGuidanceResponseActionRelatedActionComponent("relatedAction", element.getRelatedAction());
- }
- if (element.hasDocumentation()) {
- for (Attachment e : element.getDocumentation())
- composeAttachment("documentation", e);
- }
- if (element.hasParticipant()) {
- for (Reference e : element.getParticipant())
- composeReference("participant", e);
- }
- if (element.hasTypeElement()) {
- composeCode("type", element.getTypeElement());
- }
- if (element.hasBehavior()) {
- for (GuidanceResponse.GuidanceResponseActionBehaviorComponent e : element.getBehavior())
- composeGuidanceResponseGuidanceResponseActionBehaviorComponent("behavior", e);
- }
- if (element.hasResource()) {
- composeReference("resource", element.getResource());
- }
- if (element.hasAction()) {
- for (GuidanceResponse.GuidanceResponseActionComponent e : element.getAction())
- composeGuidanceResponseGuidanceResponseActionComponent("action", e);
- }
- }
-
- protected void composeGuidanceResponseGuidanceResponseActionRelatedActionComponent(String name, GuidanceResponse.GuidanceResponseActionRelatedActionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeGuidanceResponseGuidanceResponseActionRelatedActionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeGuidanceResponseGuidanceResponseActionRelatedActionComponentElements(GuidanceResponse.GuidanceResponseActionRelatedActionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasActionIdentifier()) {
- composeIdentifier("actionIdentifier", element.getActionIdentifier());
- }
- if (element.hasRelationshipElement()) {
- composeCode("relationship", element.getRelationshipElement());
- }
- if (element.hasOffset()) {
- composeType("offset", element.getOffset());
- } if (element.hasAnchorElement()) {
- composeCode("anchor", element.getAnchorElement());
- }
- }
-
- protected void composeGuidanceResponseGuidanceResponseActionBehaviorComponent(String name, GuidanceResponse.GuidanceResponseActionBehaviorComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeGuidanceResponseGuidanceResponseActionBehaviorComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeGuidanceResponseGuidanceResponseActionBehaviorComponentElements(GuidanceResponse.GuidanceResponseActionBehaviorComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasValue()) {
- composeCoding("value", element.getValue());
- }
- }
-
- protected void composeHealthcareService(String name, HealthcareService element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeHealthcareServiceElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeHealthcareServiceElements(HealthcareService element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasProvidedBy()) {
- composeReference("providedBy", element.getProvidedBy());
- }
- if (element.hasServiceCategory()) {
- composeCodeableConcept("serviceCategory", element.getServiceCategory());
- }
- if (element.hasServiceType()) {
- for (CodeableConcept e : element.getServiceType())
- composeCodeableConcept("serviceType", e);
- }
- if (element.hasSpecialty()) {
- for (CodeableConcept e : element.getSpecialty())
- composeCodeableConcept("specialty", e);
- }
- if (element.hasLocation()) {
- for (Reference e : element.getLocation())
- composeReference("location", e);
- }
- if (element.hasServiceNameElement()) {
- composeString("serviceName", element.getServiceNameElement());
- }
- if (element.hasCommentElement()) {
- composeString("comment", element.getCommentElement());
- }
- if (element.hasExtraDetailsElement()) {
- composeString("extraDetails", element.getExtraDetailsElement());
- }
- if (element.hasPhoto()) {
- composeAttachment("photo", element.getPhoto());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasCoverageArea()) {
- for (Reference e : element.getCoverageArea())
- composeReference("coverageArea", e);
- }
- if (element.hasServiceProvisionCode()) {
- for (CodeableConcept e : element.getServiceProvisionCode())
- composeCodeableConcept("serviceProvisionCode", e);
- }
- if (element.hasEligibility()) {
- composeCodeableConcept("eligibility", element.getEligibility());
- }
- if (element.hasEligibilityNoteElement()) {
- composeString("eligibilityNote", element.getEligibilityNoteElement());
- }
- if (element.hasProgramName()) {
- for (StringType e : element.getProgramName())
- composeString("programName", e);
- }
- if (element.hasCharacteristic()) {
- for (CodeableConcept e : element.getCharacteristic())
- composeCodeableConcept("characteristic", e);
- }
- if (element.hasReferralMethod()) {
- for (CodeableConcept e : element.getReferralMethod())
- composeCodeableConcept("referralMethod", e);
- }
- if (element.hasPublicKeyElement()) {
- composeString("publicKey", element.getPublicKeyElement());
- }
- if (element.hasAppointmentRequiredElement()) {
- composeBoolean("appointmentRequired", element.getAppointmentRequiredElement());
- }
- if (element.hasAvailableTime()) {
- for (HealthcareService.HealthcareServiceAvailableTimeComponent e : element.getAvailableTime())
- composeHealthcareServiceHealthcareServiceAvailableTimeComponent("availableTime", e);
- }
- if (element.hasNotAvailable()) {
- for (HealthcareService.HealthcareServiceNotAvailableComponent e : element.getNotAvailable())
- composeHealthcareServiceHealthcareServiceNotAvailableComponent("notAvailable", e);
- }
- if (element.hasAvailabilityExceptionsElement()) {
- composeString("availabilityExceptions", element.getAvailabilityExceptionsElement());
- }
- }
-
- protected void composeHealthcareServiceHealthcareServiceAvailableTimeComponent(String name, HealthcareService.HealthcareServiceAvailableTimeComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeHealthcareServiceHealthcareServiceAvailableTimeComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeHealthcareServiceHealthcareServiceAvailableTimeComponentElements(HealthcareService.HealthcareServiceAvailableTimeComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDaysOfWeek())
- for (Enumeration e : element.getDaysOfWeek())
- composeEnumeration("daysOfWeek", e, new HealthcareService.DaysOfWeekEnumFactory());
- if (element.hasAllDayElement()) {
- composeBoolean("allDay", element.getAllDayElement());
- }
- if (element.hasAvailableStartTimeElement()) {
- composeTime("availableStartTime", element.getAvailableStartTimeElement());
- }
- if (element.hasAvailableEndTimeElement()) {
- composeTime("availableEndTime", element.getAvailableEndTimeElement());
- }
- }
-
- protected void composeHealthcareServiceHealthcareServiceNotAvailableComponent(String name, HealthcareService.HealthcareServiceNotAvailableComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeHealthcareServiceHealthcareServiceNotAvailableComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeHealthcareServiceHealthcareServiceNotAvailableComponentElements(HealthcareService.HealthcareServiceNotAvailableComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasDuring()) {
- composePeriod("during", element.getDuring());
- }
- }
-
- protected void composeImagingStudy(String name, ImagingStudy element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImagingStudyElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImagingStudyElements(ImagingStudy element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUidElement()) {
- composeOid("uid", element.getUidElement());
- }
- if (element.hasAccession()) {
- composeIdentifier("accession", element.getAccession());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasAvailabilityElement())
- composeEnumeration("availability", element.getAvailabilityElement(), new ImagingStudy.InstanceAvailabilityEnumFactory());
- if (element.hasModalityList()) {
- for (Coding e : element.getModalityList())
- composeCoding("modalityList", e);
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasStartedElement()) {
- composeDateTime("started", element.getStartedElement());
- }
- if (element.hasOrder()) {
- for (Reference e : element.getOrder())
- composeReference("order", e);
- }
- if (element.hasReferrer()) {
- composeReference("referrer", element.getReferrer());
- }
- if (element.hasInterpreter()) {
- composeReference("interpreter", element.getInterpreter());
- }
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasNumberOfSeriesElement()) {
- composeUnsignedInt("numberOfSeries", element.getNumberOfSeriesElement());
- }
- if (element.hasNumberOfInstancesElement()) {
- composeUnsignedInt("numberOfInstances", element.getNumberOfInstancesElement());
- }
- if (element.hasProcedure()) {
- for (Reference e : element.getProcedure())
- composeReference("procedure", e);
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasSeries()) {
- for (ImagingStudy.ImagingStudySeriesComponent e : element.getSeries())
- composeImagingStudyImagingStudySeriesComponent("series", e);
- }
- }
-
- protected void composeImagingStudyImagingStudySeriesComponent(String name, ImagingStudy.ImagingStudySeriesComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImagingStudyImagingStudySeriesComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImagingStudyImagingStudySeriesComponentElements(ImagingStudy.ImagingStudySeriesComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasUidElement()) {
- composeOid("uid", element.getUidElement());
- }
- if (element.hasNumberElement()) {
- composeUnsignedInt("number", element.getNumberElement());
- }
- if (element.hasModality()) {
- composeCoding("modality", element.getModality());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasNumberOfInstancesElement()) {
- composeUnsignedInt("numberOfInstances", element.getNumberOfInstancesElement());
- }
- if (element.hasAvailabilityElement())
- composeEnumeration("availability", element.getAvailabilityElement(), new ImagingStudy.InstanceAvailabilityEnumFactory());
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasBodySite()) {
- composeCoding("bodySite", element.getBodySite());
- }
- if (element.hasLaterality()) {
- composeCoding("laterality", element.getLaterality());
- }
- if (element.hasStartedElement()) {
- composeDateTime("started", element.getStartedElement());
- }
- if (element.hasInstance()) {
- for (ImagingStudy.ImagingStudySeriesInstanceComponent e : element.getInstance())
- composeImagingStudyImagingStudySeriesInstanceComponent("instance", e);
- }
- }
-
- protected void composeImagingStudyImagingStudySeriesInstanceComponent(String name, ImagingStudy.ImagingStudySeriesInstanceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImagingStudyImagingStudySeriesInstanceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImagingStudyImagingStudySeriesInstanceComponentElements(ImagingStudy.ImagingStudySeriesInstanceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasUidElement()) {
- composeOid("uid", element.getUidElement());
- }
- if (element.hasNumberElement()) {
- composeUnsignedInt("number", element.getNumberElement());
- }
- if (element.hasSopClassElement()) {
- composeOid("sopClass", element.getSopClassElement());
- }
- if (element.hasTypeElement()) {
- composeString("type", element.getTypeElement());
- }
- if (element.hasTitleElement()) {
- composeString("title", element.getTitleElement());
- }
- if (element.hasContent()) {
- for (Attachment e : element.getContent())
- composeAttachment("content", e);
- }
- }
-
- protected void composeImmunization(String name, Immunization element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImmunizationElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImmunizationElements(Immunization element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement()) {
- composeCode("status", element.getStatusElement());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasVaccineCode()) {
- composeCodeableConcept("vaccineCode", element.getVaccineCode());
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasWasNotGivenElement()) {
- composeBoolean("wasNotGiven", element.getWasNotGivenElement());
- }
- if (element.hasReportedElement()) {
- composeBoolean("reported", element.getReportedElement());
- }
- if (element.hasPerformer()) {
- composeReference("performer", element.getPerformer());
- }
- if (element.hasRequester()) {
- composeReference("requester", element.getRequester());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasManufacturer()) {
- composeReference("manufacturer", element.getManufacturer());
- }
- if (element.hasLocation()) {
- composeReference("location", element.getLocation());
- }
- if (element.hasLotNumberElement()) {
- composeString("lotNumber", element.getLotNumberElement());
- }
- if (element.hasExpirationDateElement()) {
- composeDate("expirationDate", element.getExpirationDateElement());
- }
- if (element.hasSite()) {
- composeCodeableConcept("site", element.getSite());
- }
- if (element.hasRoute()) {
- composeCodeableConcept("route", element.getRoute());
- }
- if (element.hasDoseQuantity()) {
- composeSimpleQuantity("doseQuantity", element.getDoseQuantity());
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- if (element.hasExplanation()) {
- composeImmunizationImmunizationExplanationComponent("explanation", element.getExplanation());
- }
- if (element.hasReaction()) {
- for (Immunization.ImmunizationReactionComponent e : element.getReaction())
- composeImmunizationImmunizationReactionComponent("reaction", e);
- }
- if (element.hasVaccinationProtocol()) {
- for (Immunization.ImmunizationVaccinationProtocolComponent e : element.getVaccinationProtocol())
- composeImmunizationImmunizationVaccinationProtocolComponent("vaccinationProtocol", e);
- }
- }
-
- protected void composeImmunizationImmunizationExplanationComponent(String name, Immunization.ImmunizationExplanationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImmunizationImmunizationExplanationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImmunizationImmunizationExplanationComponentElements(Immunization.ImmunizationExplanationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasReason()) {
- for (CodeableConcept e : element.getReason())
- composeCodeableConcept("reason", e);
- }
- if (element.hasReasonNotGiven()) {
- for (CodeableConcept e : element.getReasonNotGiven())
- composeCodeableConcept("reasonNotGiven", e);
- }
- }
-
- protected void composeImmunizationImmunizationReactionComponent(String name, Immunization.ImmunizationReactionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImmunizationImmunizationReactionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImmunizationImmunizationReactionComponentElements(Immunization.ImmunizationReactionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasDetail()) {
- composeReference("detail", element.getDetail());
- }
- if (element.hasReportedElement()) {
- composeBoolean("reported", element.getReportedElement());
- }
- }
-
- protected void composeImmunizationImmunizationVaccinationProtocolComponent(String name, Immunization.ImmunizationVaccinationProtocolComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImmunizationImmunizationVaccinationProtocolComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImmunizationImmunizationVaccinationProtocolComponentElements(Immunization.ImmunizationVaccinationProtocolComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDoseSequenceElement()) {
- composePositiveInt("doseSequence", element.getDoseSequenceElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasAuthority()) {
- composeReference("authority", element.getAuthority());
- }
- if (element.hasSeriesElement()) {
- composeString("series", element.getSeriesElement());
- }
- if (element.hasSeriesDosesElement()) {
- composePositiveInt("seriesDoses", element.getSeriesDosesElement());
- }
- if (element.hasTargetDisease()) {
- for (CodeableConcept e : element.getTargetDisease())
- composeCodeableConcept("targetDisease", e);
- }
- if (element.hasDoseStatus()) {
- composeCodeableConcept("doseStatus", element.getDoseStatus());
- }
- if (element.hasDoseStatusReason()) {
- composeCodeableConcept("doseStatusReason", element.getDoseStatusReason());
- }
- }
-
- protected void composeImmunizationRecommendation(String name, ImmunizationRecommendation element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImmunizationRecommendationElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImmunizationRecommendationElements(ImmunizationRecommendation element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasRecommendation()) {
- for (ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent e : element.getRecommendation())
- composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent("recommendation", e);
- }
- }
-
- protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationComponent(String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImmunizationRecommendationImmunizationRecommendationRecommendationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationComponentElements(ImmunizationRecommendation.ImmunizationRecommendationRecommendationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasVaccineCode()) {
- composeCodeableConcept("vaccineCode", element.getVaccineCode());
- }
- if (element.hasDoseNumberElement()) {
- composePositiveInt("doseNumber", element.getDoseNumberElement());
- }
- if (element.hasForecastStatus()) {
- composeCodeableConcept("forecastStatus", element.getForecastStatus());
- }
- if (element.hasDateCriterion()) {
- for (ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent e : element.getDateCriterion())
- composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent("dateCriterion", e);
- }
- if (element.hasProtocol()) {
- composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent("protocol", element.getProtocol());
- }
- if (element.hasSupportingImmunization()) {
- for (Reference e : element.getSupportingImmunization())
- composeReference("supportingImmunization", e);
- }
- if (element.hasSupportingPatientInformation()) {
- for (Reference e : element.getSupportingPatientInformation())
- composeReference("supportingPatientInformation", e);
- }
- }
-
- protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponent(String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationDateCriterionComponentElements(ImmunizationRecommendation.ImmunizationRecommendationRecommendationDateCriterionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasValueElement()) {
- composeDateTime("value", element.getValueElement());
- }
- }
-
- protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponent(String name, ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImmunizationRecommendationImmunizationRecommendationRecommendationProtocolComponentElements(ImmunizationRecommendation.ImmunizationRecommendationRecommendationProtocolComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDoseSequenceElement()) {
- composeInteger("doseSequence", element.getDoseSequenceElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasAuthority()) {
- composeReference("authority", element.getAuthority());
- }
- if (element.hasSeriesElement()) {
- composeString("series", element.getSeriesElement());
- }
- }
-
- protected void composeImplementationGuide(String name, ImplementationGuide element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImplementationGuideElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImplementationGuideElements(ImplementationGuide element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (ImplementationGuide.ImplementationGuideContactComponent e : element.getContact())
- composeImplementationGuideImplementationGuideContactComponent("contact", e);
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasCopyrightElement()) {
- composeString("copyright", element.getCopyrightElement());
- }
- if (element.hasFhirVersionElement()) {
- composeId("fhirVersion", element.getFhirVersionElement());
- }
- if (element.hasDependency()) {
- for (ImplementationGuide.ImplementationGuideDependencyComponent e : element.getDependency())
- composeImplementationGuideImplementationGuideDependencyComponent("dependency", e);
- }
- if (element.hasPackage()) {
- for (ImplementationGuide.ImplementationGuidePackageComponent e : element.getPackage())
- composeImplementationGuideImplementationGuidePackageComponent("package", e);
- }
- if (element.hasGlobal()) {
- for (ImplementationGuide.ImplementationGuideGlobalComponent e : element.getGlobal())
- composeImplementationGuideImplementationGuideGlobalComponent("global", e);
- }
- if (element.hasBinary()) {
- for (UriType e : element.getBinary())
- composeUri("binary", e);
- }
- if (element.hasPage()) {
- composeImplementationGuideImplementationGuidePageComponent("page", element.getPage());
- }
- }
-
- protected void composeImplementationGuideImplementationGuideContactComponent(String name, ImplementationGuide.ImplementationGuideContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImplementationGuideImplementationGuideContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImplementationGuideImplementationGuideContactComponentElements(ImplementationGuide.ImplementationGuideContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeImplementationGuideImplementationGuideDependencyComponent(String name, ImplementationGuide.ImplementationGuideDependencyComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImplementationGuideImplementationGuideDependencyComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImplementationGuideImplementationGuideDependencyComponentElements(ImplementationGuide.ImplementationGuideDependencyComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new ImplementationGuide.GuideDependencyTypeEnumFactory());
- if (element.hasUriElement()) {
- composeUri("uri", element.getUriElement());
- }
- }
-
- protected void composeImplementationGuideImplementationGuidePackageComponent(String name, ImplementationGuide.ImplementationGuidePackageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImplementationGuideImplementationGuidePackageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImplementationGuideImplementationGuidePackageComponentElements(ImplementationGuide.ImplementationGuidePackageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasResource()) {
- for (ImplementationGuide.ImplementationGuidePackageResourceComponent e : element.getResource())
- composeImplementationGuideImplementationGuidePackageResourceComponent("resource", e);
- }
- }
-
- protected void composeImplementationGuideImplementationGuidePackageResourceComponent(String name, ImplementationGuide.ImplementationGuidePackageResourceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImplementationGuideImplementationGuidePackageResourceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImplementationGuideImplementationGuidePackageResourceComponentElements(ImplementationGuide.ImplementationGuidePackageResourceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasExampleElement()) {
- composeBoolean("example", element.getExampleElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasAcronymElement()) {
- composeString("acronym", element.getAcronymElement());
- }
- if (element.hasSource()) {
- composeType("source", element.getSource());
- } if (element.hasExampleFor()) {
- composeReference("exampleFor", element.getExampleFor());
- }
- }
-
- protected void composeImplementationGuideImplementationGuideGlobalComponent(String name, ImplementationGuide.ImplementationGuideGlobalComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImplementationGuideImplementationGuideGlobalComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImplementationGuideImplementationGuideGlobalComponentElements(ImplementationGuide.ImplementationGuideGlobalComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement()) {
- composeCode("type", element.getTypeElement());
- }
- if (element.hasProfile()) {
- composeReference("profile", element.getProfile());
- }
- }
-
- protected void composeImplementationGuideImplementationGuidePageComponent(String name, ImplementationGuide.ImplementationGuidePageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeImplementationGuideImplementationGuidePageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeImplementationGuideImplementationGuidePageComponentElements(ImplementationGuide.ImplementationGuidePageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSourceElement()) {
- composeUri("source", element.getSourceElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasKindElement())
- composeEnumeration("kind", element.getKindElement(), new ImplementationGuide.GuidePageKindEnumFactory());
- if (element.hasType()) {
- for (CodeType e : element.getType())
- composeCode("type", e);
- }
- if (element.hasPackage()) {
- for (StringType e : element.getPackage())
- composeString("package", e);
- }
- if (element.hasFormatElement()) {
- composeCode("format", element.getFormatElement());
- }
- if (element.hasPage()) {
- for (ImplementationGuide.ImplementationGuidePageComponent e : element.getPage())
- composeImplementationGuideImplementationGuidePageComponent("page", e);
- }
- }
-
- protected void composeLibrary(String name, Library element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeLibraryElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeLibraryElements(Library element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasModuleMetadata()) {
- composeModuleMetadata("moduleMetadata", element.getModuleMetadata());
- }
- if (element.hasModel()) {
- for (Library.LibraryModelComponent e : element.getModel())
- composeLibraryLibraryModelComponent("model", e);
- }
- if (element.hasLibrary()) {
- for (Library.LibraryLibraryComponent e : element.getLibrary())
- composeLibraryLibraryLibraryComponent("library", e);
- }
- if (element.hasCodeSystem()) {
- for (Library.LibraryCodeSystemComponent e : element.getCodeSystem())
- composeLibraryLibraryCodeSystemComponent("codeSystem", e);
- }
- if (element.hasValueSet()) {
- for (Library.LibraryValueSetComponent e : element.getValueSet())
- composeLibraryLibraryValueSetComponent("valueSet", e);
- }
- if (element.hasParameter()) {
- for (ParameterDefinition e : element.getParameter())
- composeParameterDefinition("parameter", e);
- }
- if (element.hasDataRequirement()) {
- for (DataRequirement e : element.getDataRequirement())
- composeDataRequirement("dataRequirement", e);
- }
- if (element.hasDocument()) {
- composeAttachment("document", element.getDocument());
- }
- }
-
- protected void composeLibraryLibraryModelComponent(String name, Library.LibraryModelComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeLibraryLibraryModelComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeLibraryLibraryModelComponentElements(Library.LibraryModelComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasIdentifierElement()) {
- composeString("identifier", element.getIdentifierElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- }
-
- protected void composeLibraryLibraryLibraryComponent(String name, Library.LibraryLibraryComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeLibraryLibraryLibraryComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeLibraryLibraryLibraryComponentElements(Library.LibraryLibraryComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasIdentifierElement()) {
- composeString("identifier", element.getIdentifierElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasDocument()) {
- composeType("document", element.getDocument());
- } }
-
- protected void composeLibraryLibraryCodeSystemComponent(String name, Library.LibraryCodeSystemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeLibraryLibraryCodeSystemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeLibraryLibraryCodeSystemComponentElements(Library.LibraryCodeSystemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasIdentifierElement()) {
- composeString("identifier", element.getIdentifierElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- }
-
- protected void composeLibraryLibraryValueSetComponent(String name, Library.LibraryValueSetComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeLibraryLibraryValueSetComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeLibraryLibraryValueSetComponentElements(Library.LibraryValueSetComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasIdentifierElement()) {
- composeString("identifier", element.getIdentifierElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasCodeSystem()) {
- for (StringType e : element.getCodeSystem())
- composeString("codeSystem", e);
- }
- }
-
- protected void composeLinkage(String name, Linkage element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeLinkageElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeLinkageElements(Linkage element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasAuthor()) {
- composeReference("author", element.getAuthor());
- }
- if (element.hasItem()) {
- for (Linkage.LinkageItemComponent e : element.getItem())
- composeLinkageLinkageItemComponent("item", e);
- }
- }
-
- protected void composeLinkageLinkageItemComponent(String name, Linkage.LinkageItemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeLinkageLinkageItemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeLinkageLinkageItemComponentElements(Linkage.LinkageItemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Linkage.LinkageTypeEnumFactory());
- if (element.hasResource()) {
- composeReference("resource", element.getResource());
- }
- }
-
- protected void composeListResource(String name, ListResource element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeListResourceElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeListResourceElements(ListResource element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new ListResource.ListStatusEnumFactory());
- if (element.hasModeElement())
- composeEnumeration("mode", element.getModeElement(), new ListResource.ListModeEnumFactory());
- if (element.hasTitleElement()) {
- composeString("title", element.getTitleElement());
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasSource()) {
- composeReference("source", element.getSource());
- }
- if (element.hasOrderedBy()) {
- composeCodeableConcept("orderedBy", element.getOrderedBy());
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- if (element.hasEntry()) {
- for (ListResource.ListEntryComponent e : element.getEntry())
- composeListResourceListEntryComponent("entry", e);
- }
- if (element.hasEmptyReason()) {
- composeCodeableConcept("emptyReason", element.getEmptyReason());
- }
- }
-
- protected void composeListResourceListEntryComponent(String name, ListResource.ListEntryComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeListResourceListEntryComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeListResourceListEntryComponentElements(ListResource.ListEntryComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasFlag()) {
- composeCodeableConcept("flag", element.getFlag());
- }
- if (element.hasDeletedElement()) {
- composeBoolean("deleted", element.getDeletedElement());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasItem()) {
- composeReference("item", element.getItem());
- }
- }
-
- protected void composeLocation(String name, Location element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeLocationElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeLocationElements(Location element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Location.LocationStatusEnumFactory());
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasModeElement())
- composeEnumeration("mode", element.getModeElement(), new Location.LocationModeEnumFactory());
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasAddress()) {
- composeAddress("address", element.getAddress());
- }
- if (element.hasPhysicalType()) {
- composeCodeableConcept("physicalType", element.getPhysicalType());
- }
- if (element.hasPosition()) {
- composeLocationLocationPositionComponent("position", element.getPosition());
- }
- if (element.hasManagingOrganization()) {
- composeReference("managingOrganization", element.getManagingOrganization());
- }
- if (element.hasPartOf()) {
- composeReference("partOf", element.getPartOf());
- }
- }
-
- protected void composeLocationLocationPositionComponent(String name, Location.LocationPositionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeLocationLocationPositionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeLocationLocationPositionComponentElements(Location.LocationPositionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLongitudeElement()) {
- composeDecimal("longitude", element.getLongitudeElement());
- }
- if (element.hasLatitudeElement()) {
- composeDecimal("latitude", element.getLatitudeElement());
- }
- if (element.hasAltitudeElement()) {
- composeDecimal("altitude", element.getAltitudeElement());
- }
- }
-
- protected void composeMeasure(String name, Measure element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureElements(Measure element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasModuleMetadata()) {
- composeModuleMetadata("moduleMetadata", element.getModuleMetadata());
- }
- if (element.hasLibrary()) {
- for (Reference e : element.getLibrary())
- composeReference("library", e);
- }
- if (element.hasDisclaimerElement()) {
- composeMarkdown("disclaimer", element.getDisclaimerElement());
- }
- if (element.hasScoringElement())
- composeEnumeration("scoring", element.getScoringElement(), new Measure.MeasureScoringEnumFactory());
- if (element.hasType())
- for (Enumeration e : element.getType())
- composeEnumeration("type", e, new Measure.MeasureTypeEnumFactory());
- if (element.hasRiskAdjustmentElement()) {
- composeString("riskAdjustment", element.getRiskAdjustmentElement());
- }
- if (element.hasRateAggregationElement()) {
- composeString("rateAggregation", element.getRateAggregationElement());
- }
- if (element.hasRationaleElement()) {
- composeMarkdown("rationale", element.getRationaleElement());
- }
- if (element.hasClinicalRecommendationStatementElement()) {
- composeMarkdown("clinicalRecommendationStatement", element.getClinicalRecommendationStatementElement());
- }
- if (element.hasImprovementNotationElement()) {
- composeString("improvementNotation", element.getImprovementNotationElement());
- }
- if (element.hasDefinitionElement()) {
- composeMarkdown("definition", element.getDefinitionElement());
- }
- if (element.hasGuidanceElement()) {
- composeMarkdown("guidance", element.getGuidanceElement());
- }
- if (element.hasSetElement()) {
- composeString("set", element.getSetElement());
- }
- if (element.hasGroup()) {
- for (Measure.MeasureGroupComponent e : element.getGroup())
- composeMeasureMeasureGroupComponent("group", e);
- }
- if (element.hasSupplementalData()) {
- for (Measure.MeasureSupplementalDataComponent e : element.getSupplementalData())
- composeMeasureMeasureSupplementalDataComponent("supplementalData", e);
- }
- }
-
- protected void composeMeasureMeasureGroupComponent(String name, Measure.MeasureGroupComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureMeasureGroupComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureMeasureGroupComponentElements(Measure.MeasureGroupComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasPopulation()) {
- for (Measure.MeasureGroupPopulationComponent e : element.getPopulation())
- composeMeasureMeasureGroupPopulationComponent("population", e);
- }
- if (element.hasStratifier()) {
- for (Measure.MeasureGroupStratifierComponent e : element.getStratifier())
- composeMeasureMeasureGroupStratifierComponent("stratifier", e);
- }
- }
-
- protected void composeMeasureMeasureGroupPopulationComponent(String name, Measure.MeasureGroupPopulationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureMeasureGroupPopulationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureMeasureGroupPopulationComponentElements(Measure.MeasureGroupPopulationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Measure.MeasurePopulationTypeEnumFactory());
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasCriteriaElement()) {
- composeString("criteria", element.getCriteriaElement());
- }
- }
-
- protected void composeMeasureMeasureGroupStratifierComponent(String name, Measure.MeasureGroupStratifierComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureMeasureGroupStratifierComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureMeasureGroupStratifierComponentElements(Measure.MeasureGroupStratifierComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasCriteriaElement()) {
- composeString("criteria", element.getCriteriaElement());
- }
- if (element.hasPathElement()) {
- composeString("path", element.getPathElement());
- }
- }
-
- protected void composeMeasureMeasureSupplementalDataComponent(String name, Measure.MeasureSupplementalDataComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureMeasureSupplementalDataComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureMeasureSupplementalDataComponentElements(Measure.MeasureSupplementalDataComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasUsage())
- for (Enumeration e : element.getUsage())
- composeEnumeration("usage", e, new Measure.MeasureDataUsageEnumFactory());
- if (element.hasCriteriaElement()) {
- composeString("criteria", element.getCriteriaElement());
- }
- if (element.hasPathElement()) {
- composeString("path", element.getPathElement());
- }
- }
-
- protected void composeMeasureReport(String name, MeasureReport element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureReportElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureReportElements(MeasureReport element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasMeasure()) {
- composeReference("measure", element.getMeasure());
- }
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new MeasureReport.MeasureReportTypeEnumFactory());
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new MeasureReport.MeasureReportStatusEnumFactory());
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasReportingOrganization()) {
- composeReference("reportingOrganization", element.getReportingOrganization());
- }
- if (element.hasGroup()) {
- for (MeasureReport.MeasureReportGroupComponent e : element.getGroup())
- composeMeasureReportMeasureReportGroupComponent("group", e);
- }
- if (element.hasEvaluatedResources()) {
- composeReference("evaluatedResources", element.getEvaluatedResources());
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupComponent(String name, MeasureReport.MeasureReportGroupComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureReportMeasureReportGroupComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupComponentElements(MeasureReport.MeasureReportGroupComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasPopulation()) {
- for (MeasureReport.MeasureReportGroupPopulationComponent e : element.getPopulation())
- composeMeasureReportMeasureReportGroupPopulationComponent("population", e);
- }
- if (element.hasMeasureScoreElement()) {
- composeDecimal("measureScore", element.getMeasureScoreElement());
- }
- if (element.hasStratifier()) {
- for (MeasureReport.MeasureReportGroupStratifierComponent e : element.getStratifier())
- composeMeasureReportMeasureReportGroupStratifierComponent("stratifier", e);
- }
- if (element.hasSupplementalData()) {
- for (MeasureReport.MeasureReportGroupSupplementalDataComponent e : element.getSupplementalData())
- composeMeasureReportMeasureReportGroupSupplementalDataComponent("supplementalData", e);
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupPopulationComponent(String name, MeasureReport.MeasureReportGroupPopulationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureReportMeasureReportGroupPopulationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupPopulationComponentElements(MeasureReport.MeasureReportGroupPopulationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement()) {
- composeCode("type", element.getTypeElement());
- }
- if (element.hasCountElement()) {
- composeInteger("count", element.getCountElement());
- }
- if (element.hasPatients()) {
- composeReference("patients", element.getPatients());
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupStratifierComponent(String name, MeasureReport.MeasureReportGroupStratifierComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureReportMeasureReportGroupStratifierComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupStratifierComponentElements(MeasureReport.MeasureReportGroupStratifierComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasGroup()) {
- for (MeasureReport.MeasureReportGroupStratifierGroupComponent e : element.getGroup())
- composeMeasureReportMeasureReportGroupStratifierGroupComponent("group", e);
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupStratifierGroupComponent(String name, MeasureReport.MeasureReportGroupStratifierGroupComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureReportMeasureReportGroupStratifierGroupComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupStratifierGroupComponentElements(MeasureReport.MeasureReportGroupStratifierGroupComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- if (element.hasPopulation()) {
- for (MeasureReport.MeasureReportGroupStratifierGroupPopulationComponent e : element.getPopulation())
- composeMeasureReportMeasureReportGroupStratifierGroupPopulationComponent("population", e);
- }
- if (element.hasMeasureScoreElement()) {
- composeDecimal("measureScore", element.getMeasureScoreElement());
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupStratifierGroupPopulationComponent(String name, MeasureReport.MeasureReportGroupStratifierGroupPopulationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureReportMeasureReportGroupStratifierGroupPopulationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupStratifierGroupPopulationComponentElements(MeasureReport.MeasureReportGroupStratifierGroupPopulationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement()) {
- composeCode("type", element.getTypeElement());
- }
- if (element.hasCountElement()) {
- composeInteger("count", element.getCountElement());
- }
- if (element.hasPatients()) {
- composeReference("patients", element.getPatients());
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupSupplementalDataComponent(String name, MeasureReport.MeasureReportGroupSupplementalDataComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureReportMeasureReportGroupSupplementalDataComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupSupplementalDataComponentElements(MeasureReport.MeasureReportGroupSupplementalDataComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasGroup()) {
- for (MeasureReport.MeasureReportGroupSupplementalDataGroupComponent e : element.getGroup())
- composeMeasureReportMeasureReportGroupSupplementalDataGroupComponent("group", e);
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupSupplementalDataGroupComponent(String name, MeasureReport.MeasureReportGroupSupplementalDataGroupComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMeasureReportMeasureReportGroupSupplementalDataGroupComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMeasureReportMeasureReportGroupSupplementalDataGroupComponentElements(MeasureReport.MeasureReportGroupSupplementalDataGroupComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- if (element.hasCountElement()) {
- composeInteger("count", element.getCountElement());
- }
- if (element.hasPatients()) {
- composeReference("patients", element.getPatients());
- }
- }
-
- protected void composeMedia(String name, Media element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMediaElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMediaElements(Media element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Media.DigitalMediaTypeEnumFactory());
- if (element.hasSubtype()) {
- composeCodeableConcept("subtype", element.getSubtype());
- }
- if (element.hasView()) {
- composeCodeableConcept("view", element.getView());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasOperator()) {
- composeReference("operator", element.getOperator());
- }
- if (element.hasDeviceNameElement()) {
- composeString("deviceName", element.getDeviceNameElement());
- }
- if (element.hasHeightElement()) {
- composePositiveInt("height", element.getHeightElement());
- }
- if (element.hasWidthElement()) {
- composePositiveInt("width", element.getWidthElement());
- }
- if (element.hasFramesElement()) {
- composePositiveInt("frames", element.getFramesElement());
- }
- if (element.hasDurationElement()) {
- composeUnsignedInt("duration", element.getDurationElement());
- }
- if (element.hasContent()) {
- composeAttachment("content", element.getContent());
- }
- }
-
- protected void composeMedication(String name, Medication element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationElements(Medication element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasIsBrandElement()) {
- composeBoolean("isBrand", element.getIsBrandElement());
- }
- if (element.hasManufacturer()) {
- composeReference("manufacturer", element.getManufacturer());
- }
- if (element.hasProduct()) {
- composeMedicationMedicationProductComponent("product", element.getProduct());
- }
- if (element.hasPackage()) {
- composeMedicationMedicationPackageComponent("package", element.getPackage());
- }
- }
-
- protected void composeMedicationMedicationProductComponent(String name, Medication.MedicationProductComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationMedicationProductComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationMedicationProductComponentElements(Medication.MedicationProductComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasForm()) {
- composeCodeableConcept("form", element.getForm());
- }
- if (element.hasIngredient()) {
- for (Medication.MedicationProductIngredientComponent e : element.getIngredient())
- composeMedicationMedicationProductIngredientComponent("ingredient", e);
- }
- if (element.hasBatch()) {
- for (Medication.MedicationProductBatchComponent e : element.getBatch())
- composeMedicationMedicationProductBatchComponent("batch", e);
- }
- }
-
- protected void composeMedicationMedicationProductIngredientComponent(String name, Medication.MedicationProductIngredientComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationMedicationProductIngredientComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationMedicationProductIngredientComponentElements(Medication.MedicationProductIngredientComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasItem()) {
- composeType("item", element.getItem());
- } if (element.hasAmount()) {
- composeRatio("amount", element.getAmount());
- }
- }
-
- protected void composeMedicationMedicationProductBatchComponent(String name, Medication.MedicationProductBatchComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationMedicationProductBatchComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationMedicationProductBatchComponentElements(Medication.MedicationProductBatchComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLotNumberElement()) {
- composeString("lotNumber", element.getLotNumberElement());
- }
- if (element.hasExpirationDateElement()) {
- composeDateTime("expirationDate", element.getExpirationDateElement());
- }
- }
-
- protected void composeMedicationMedicationPackageComponent(String name, Medication.MedicationPackageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationMedicationPackageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationMedicationPackageComponentElements(Medication.MedicationPackageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasContainer()) {
- composeCodeableConcept("container", element.getContainer());
- }
- if (element.hasContent()) {
- for (Medication.MedicationPackageContentComponent e : element.getContent())
- composeMedicationMedicationPackageContentComponent("content", e);
- }
- }
-
- protected void composeMedicationMedicationPackageContentComponent(String name, Medication.MedicationPackageContentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationMedicationPackageContentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationMedicationPackageContentComponentElements(Medication.MedicationPackageContentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasItem()) {
- composeType("item", element.getItem());
- } if (element.hasAmount()) {
- composeSimpleQuantity("amount", element.getAmount());
- }
- }
-
- protected void composeMedicationAdministration(String name, MedicationAdministration element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationAdministrationElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationAdministrationElements(MedicationAdministration element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new MedicationAdministration.MedicationAdministrationStatusEnumFactory());
- if (element.hasMedication()) {
- composeType("medication", element.getMedication());
- } if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasEffectiveTime()) {
- composeType("effectiveTime", element.getEffectiveTime());
- } if (element.hasPerformer()) {
- composeReference("performer", element.getPerformer());
- }
- if (element.hasPrescription()) {
- composeReference("prescription", element.getPrescription());
- }
- if (element.hasWasNotGivenElement()) {
- composeBoolean("wasNotGiven", element.getWasNotGivenElement());
- }
- if (element.hasReasonNotGiven()) {
- for (CodeableConcept e : element.getReasonNotGiven())
- composeCodeableConcept("reasonNotGiven", e);
- }
- if (element.hasReasonGiven()) {
- for (CodeableConcept e : element.getReasonGiven())
- composeCodeableConcept("reasonGiven", e);
- }
- if (element.hasDevice()) {
- for (Reference e : element.getDevice())
- composeReference("device", e);
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- if (element.hasDosage()) {
- composeMedicationAdministrationMedicationAdministrationDosageComponent("dosage", element.getDosage());
- }
- if (element.hasEventHistory()) {
- for (MedicationAdministration.MedicationAdministrationEventHistoryComponent e : element.getEventHistory())
- composeMedicationAdministrationMedicationAdministrationEventHistoryComponent("eventHistory", e);
- }
- }
-
- protected void composeMedicationAdministrationMedicationAdministrationDosageComponent(String name, MedicationAdministration.MedicationAdministrationDosageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationAdministrationMedicationAdministrationDosageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationAdministrationMedicationAdministrationDosageComponentElements(MedicationAdministration.MedicationAdministrationDosageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- if (element.hasSite()) {
- composeType("site", element.getSite());
- } if (element.hasRoute()) {
- composeCodeableConcept("route", element.getRoute());
- }
- if (element.hasMethod()) {
- composeCodeableConcept("method", element.getMethod());
- }
- if (element.hasDose()) {
- composeSimpleQuantity("dose", element.getDose());
- }
- if (element.hasRate()) {
- composeType("rate", element.getRate());
- } }
-
- protected void composeMedicationAdministrationMedicationAdministrationEventHistoryComponent(String name, MedicationAdministration.MedicationAdministrationEventHistoryComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationAdministrationMedicationAdministrationEventHistoryComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationAdministrationMedicationAdministrationEventHistoryComponentElements(MedicationAdministration.MedicationAdministrationEventHistoryComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new MedicationAdministration.MedicationAdministrationStatusEnumFactory());
- if (element.hasAction()) {
- composeCodeableConcept("action", element.getAction());
- }
- if (element.hasDateTimeElement()) {
- composeDateTime("dateTime", element.getDateTimeElement());
- }
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasReason()) {
- composeCodeableConcept("reason", element.getReason());
- }
- }
-
- protected void composeMedicationDispense(String name, MedicationDispense element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationDispenseElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationDispenseElements(MedicationDispense element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new MedicationDispense.MedicationDispenseStatusEnumFactory());
- if (element.hasMedication()) {
- composeType("medication", element.getMedication());
- } if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasDispenser()) {
- composeReference("dispenser", element.getDispenser());
- }
- if (element.hasAuthorizingPrescription()) {
- for (Reference e : element.getAuthorizingPrescription())
- composeReference("authorizingPrescription", e);
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasDaysSupply()) {
- composeSimpleQuantity("daysSupply", element.getDaysSupply());
- }
- if (element.hasWhenPreparedElement()) {
- composeDateTime("whenPrepared", element.getWhenPreparedElement());
- }
- if (element.hasWhenHandedOverElement()) {
- composeDateTime("whenHandedOver", element.getWhenHandedOverElement());
- }
- if (element.hasDestination()) {
- composeReference("destination", element.getDestination());
- }
- if (element.hasReceiver()) {
- for (Reference e : element.getReceiver())
- composeReference("receiver", e);
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- if (element.hasDosageInstruction()) {
- for (MedicationDispense.MedicationDispenseDosageInstructionComponent e : element.getDosageInstruction())
- composeMedicationDispenseMedicationDispenseDosageInstructionComponent("dosageInstruction", e);
- }
- if (element.hasSubstitution()) {
- composeMedicationDispenseMedicationDispenseSubstitutionComponent("substitution", element.getSubstitution());
- }
- if (element.hasEventHistory()) {
- for (MedicationDispense.MedicationDispenseEventHistoryComponent e : element.getEventHistory())
- composeMedicationDispenseMedicationDispenseEventHistoryComponent("eventHistory", e);
- }
- }
-
- protected void composeMedicationDispenseMedicationDispenseDosageInstructionComponent(String name, MedicationDispense.MedicationDispenseDosageInstructionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationDispenseMedicationDispenseDosageInstructionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationDispenseMedicationDispenseDosageInstructionComponentElements(MedicationDispense.MedicationDispenseDosageInstructionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- if (element.hasAdditionalInstructions()) {
- for (CodeableConcept e : element.getAdditionalInstructions())
- composeCodeableConcept("additionalInstructions", e);
- }
- if (element.hasTiming()) {
- composeTiming("timing", element.getTiming());
- }
- if (element.hasAsNeeded()) {
- composeType("asNeeded", element.getAsNeeded());
- } if (element.hasSite()) {
- composeType("site", element.getSite());
- } if (element.hasRoute()) {
- composeCodeableConcept("route", element.getRoute());
- }
- if (element.hasMethod()) {
- composeCodeableConcept("method", element.getMethod());
- }
- if (element.hasDose()) {
- composeType("dose", element.getDose());
- } if (element.hasRate()) {
- composeType("rate", element.getRate());
- } if (element.hasMaxDosePerPeriod()) {
- composeRatio("maxDosePerPeriod", element.getMaxDosePerPeriod());
- }
- }
-
- protected void composeMedicationDispenseMedicationDispenseSubstitutionComponent(String name, MedicationDispense.MedicationDispenseSubstitutionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationDispenseMedicationDispenseSubstitutionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationDispenseMedicationDispenseSubstitutionComponentElements(MedicationDispense.MedicationDispenseSubstitutionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasReason()) {
- for (CodeableConcept e : element.getReason())
- composeCodeableConcept("reason", e);
- }
- if (element.hasResponsibleParty()) {
- for (Reference e : element.getResponsibleParty())
- composeReference("responsibleParty", e);
- }
- }
-
- protected void composeMedicationDispenseMedicationDispenseEventHistoryComponent(String name, MedicationDispense.MedicationDispenseEventHistoryComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationDispenseMedicationDispenseEventHistoryComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationDispenseMedicationDispenseEventHistoryComponentElements(MedicationDispense.MedicationDispenseEventHistoryComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new MedicationDispense.MedicationDispenseStatusEnumFactory());
- if (element.hasAction()) {
- composeCodeableConcept("action", element.getAction());
- }
- if (element.hasDateTimeElement()) {
- composeDateTime("dateTime", element.getDateTimeElement());
- }
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasReason()) {
- composeCodeableConcept("reason", element.getReason());
- }
- }
-
- protected void composeMedicationOrder(String name, MedicationOrder element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationOrderElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationOrderElements(MedicationOrder element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new MedicationOrder.MedicationOrderStatusEnumFactory());
- if (element.hasMedication()) {
- composeType("medication", element.getMedication());
- } if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasDateWrittenElement()) {
- composeDateTime("dateWritten", element.getDateWrittenElement());
- }
- if (element.hasPrescriber()) {
- composeReference("prescriber", element.getPrescriber());
- }
- if (element.hasReasonCode()) {
- for (CodeableConcept e : element.getReasonCode())
- composeCodeableConcept("reasonCode", e);
- }
- if (element.hasReasonReference()) {
- for (Reference e : element.getReasonReference())
- composeReference("reasonReference", e);
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- if (element.hasDosageInstruction()) {
- for (MedicationOrder.MedicationOrderDosageInstructionComponent e : element.getDosageInstruction())
- composeMedicationOrderMedicationOrderDosageInstructionComponent("dosageInstruction", e);
- }
- if (element.hasDispenseRequest()) {
- composeMedicationOrderMedicationOrderDispenseRequestComponent("dispenseRequest", element.getDispenseRequest());
- }
- if (element.hasSubstitution()) {
- composeMedicationOrderMedicationOrderSubstitutionComponent("substitution", element.getSubstitution());
- }
- if (element.hasPriorPrescription()) {
- composeReference("priorPrescription", element.getPriorPrescription());
- }
- if (element.hasEventHistory()) {
- for (MedicationOrder.MedicationOrderEventHistoryComponent e : element.getEventHistory())
- composeMedicationOrderMedicationOrderEventHistoryComponent("eventHistory", e);
- }
- }
-
- protected void composeMedicationOrderMedicationOrderDosageInstructionComponent(String name, MedicationOrder.MedicationOrderDosageInstructionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationOrderMedicationOrderDosageInstructionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationOrderMedicationOrderDosageInstructionComponentElements(MedicationOrder.MedicationOrderDosageInstructionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- if (element.hasAdditionalInstructions()) {
- for (CodeableConcept e : element.getAdditionalInstructions())
- composeCodeableConcept("additionalInstructions", e);
- }
- if (element.hasTiming()) {
- composeTiming("timing", element.getTiming());
- }
- if (element.hasAsNeeded()) {
- composeType("asNeeded", element.getAsNeeded());
- } if (element.hasSite()) {
- composeType("site", element.getSite());
- } if (element.hasRoute()) {
- composeCodeableConcept("route", element.getRoute());
- }
- if (element.hasMethod()) {
- composeCodeableConcept("method", element.getMethod());
- }
- if (element.hasDose()) {
- composeType("dose", element.getDose());
- } if (element.hasMaxDosePerPeriod()) {
- composeRatio("maxDosePerPeriod", element.getMaxDosePerPeriod());
- }
- if (element.hasMaxDosePerAdministration()) {
- composeSimpleQuantity("maxDosePerAdministration", element.getMaxDosePerAdministration());
- }
- if (element.hasMaxDosePerLifetime()) {
- composeSimpleQuantity("maxDosePerLifetime", element.getMaxDosePerLifetime());
- }
- if (element.hasRate()) {
- composeType("rate", element.getRate());
- } }
-
- protected void composeMedicationOrderMedicationOrderDispenseRequestComponent(String name, MedicationOrder.MedicationOrderDispenseRequestComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationOrderMedicationOrderDispenseRequestComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationOrderMedicationOrderDispenseRequestComponentElements(MedicationOrder.MedicationOrderDispenseRequestComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasValidityPeriod()) {
- composePeriod("validityPeriod", element.getValidityPeriod());
- }
- if (element.hasNumberOfRepeatsAllowedElement()) {
- composePositiveInt("numberOfRepeatsAllowed", element.getNumberOfRepeatsAllowedElement());
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasExpectedSupplyDuration()) {
- composeDuration("expectedSupplyDuration", element.getExpectedSupplyDuration());
- }
- }
-
- protected void composeMedicationOrderMedicationOrderSubstitutionComponent(String name, MedicationOrder.MedicationOrderSubstitutionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationOrderMedicationOrderSubstitutionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationOrderMedicationOrderSubstitutionComponentElements(MedicationOrder.MedicationOrderSubstitutionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasAllowedElement()) {
- composeBoolean("allowed", element.getAllowedElement());
- }
- if (element.hasReason()) {
- composeCodeableConcept("reason", element.getReason());
- }
- }
-
- protected void composeMedicationOrderMedicationOrderEventHistoryComponent(String name, MedicationOrder.MedicationOrderEventHistoryComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationOrderMedicationOrderEventHistoryComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationOrderMedicationOrderEventHistoryComponentElements(MedicationOrder.MedicationOrderEventHistoryComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new MedicationOrder.MedicationOrderStatusEnumFactory());
- if (element.hasAction()) {
- composeCodeableConcept("action", element.getAction());
- }
- if (element.hasDateTimeElement()) {
- composeDateTime("dateTime", element.getDateTimeElement());
- }
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasReason()) {
- composeCodeableConcept("reason", element.getReason());
- }
- }
-
- protected void composeMedicationStatement(String name, MedicationStatement element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationStatementElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationStatementElements(MedicationStatement element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new MedicationStatement.MedicationStatementStatusEnumFactory());
- if (element.hasMedication()) {
- composeType("medication", element.getMedication());
- } if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasEffective()) {
- composeType("effective", element.getEffective());
- } if (element.hasInformationSource()) {
- composeReference("informationSource", element.getInformationSource());
- }
- if (element.hasSupportingInformation()) {
- for (Reference e : element.getSupportingInformation())
- composeReference("supportingInformation", e);
- }
- if (element.hasDateAssertedElement()) {
- composeDateTime("dateAsserted", element.getDateAssertedElement());
- }
- if (element.hasWasNotTakenElement()) {
- composeBoolean("wasNotTaken", element.getWasNotTakenElement());
- }
- if (element.hasReasonNotTaken()) {
- for (CodeableConcept e : element.getReasonNotTaken())
- composeCodeableConcept("reasonNotTaken", e);
- }
- if (element.hasReasonForUseCode()) {
- for (CodeableConcept e : element.getReasonForUseCode())
- composeCodeableConcept("reasonForUseCode", e);
- }
- if (element.hasReasonForUseReference()) {
- for (Reference e : element.getReasonForUseReference())
- composeReference("reasonForUseReference", e);
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- if (element.hasDosage()) {
- for (MedicationStatement.MedicationStatementDosageComponent e : element.getDosage())
- composeMedicationStatementMedicationStatementDosageComponent("dosage", e);
- }
- }
-
- protected void composeMedicationStatementMedicationStatementDosageComponent(String name, MedicationStatement.MedicationStatementDosageComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMedicationStatementMedicationStatementDosageComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMedicationStatementMedicationStatementDosageComponentElements(MedicationStatement.MedicationStatementDosageComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- if (element.hasAdditionalInstructions()) {
- for (CodeableConcept e : element.getAdditionalInstructions())
- composeCodeableConcept("additionalInstructions", e);
- }
- if (element.hasTiming()) {
- composeTiming("timing", element.getTiming());
- }
- if (element.hasAsNeeded()) {
- composeType("asNeeded", element.getAsNeeded());
- } if (element.hasSite()) {
- composeType("site", element.getSite());
- } if (element.hasRoute()) {
- composeCodeableConcept("route", element.getRoute());
- }
- if (element.hasMethod()) {
- composeCodeableConcept("method", element.getMethod());
- }
- if (element.hasDose()) {
- composeType("dose", element.getDose());
- } if (element.hasRate()) {
- composeType("rate", element.getRate());
- } if (element.hasMaxDosePerPeriod()) {
- composeRatio("maxDosePerPeriod", element.getMaxDosePerPeriod());
- }
- }
-
- protected void composeMessageHeader(String name, MessageHeader element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMessageHeaderElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMessageHeaderElements(MessageHeader element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasTimestampElement()) {
- composeInstant("timestamp", element.getTimestampElement());
- }
- if (element.hasEvent()) {
- composeCoding("event", element.getEvent());
- }
- if (element.hasResponse()) {
- composeMessageHeaderMessageHeaderResponseComponent("response", element.getResponse());
- }
- if (element.hasSource()) {
- composeMessageHeaderMessageSourceComponent("source", element.getSource());
- }
- if (element.hasDestination()) {
- for (MessageHeader.MessageDestinationComponent e : element.getDestination())
- composeMessageHeaderMessageDestinationComponent("destination", e);
- }
- if (element.hasEnterer()) {
- composeReference("enterer", element.getEnterer());
- }
- if (element.hasAuthor()) {
- composeReference("author", element.getAuthor());
- }
- if (element.hasReceiver()) {
- composeReference("receiver", element.getReceiver());
- }
- if (element.hasResponsible()) {
- composeReference("responsible", element.getResponsible());
- }
- if (element.hasReason()) {
- composeCodeableConcept("reason", element.getReason());
- }
- if (element.hasData()) {
- for (Reference e : element.getData())
- composeReference("data", e);
- }
- }
-
- protected void composeMessageHeaderMessageHeaderResponseComponent(String name, MessageHeader.MessageHeaderResponseComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMessageHeaderMessageHeaderResponseComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMessageHeaderMessageHeaderResponseComponentElements(MessageHeader.MessageHeaderResponseComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifierElement()) {
- composeId("identifier", element.getIdentifierElement());
- }
- if (element.hasCodeElement())
- composeEnumeration("code", element.getCodeElement(), new MessageHeader.ResponseTypeEnumFactory());
- if (element.hasDetails()) {
- composeReference("details", element.getDetails());
- }
- }
-
- protected void composeMessageHeaderMessageSourceComponent(String name, MessageHeader.MessageSourceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMessageHeaderMessageSourceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMessageHeaderMessageSourceComponentElements(MessageHeader.MessageSourceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasSoftwareElement()) {
- composeString("software", element.getSoftwareElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasContact()) {
- composeContactPoint("contact", element.getContact());
- }
- if (element.hasEndpointElement()) {
- composeUri("endpoint", element.getEndpointElement());
- }
- }
-
- protected void composeMessageHeaderMessageDestinationComponent(String name, MessageHeader.MessageDestinationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeMessageHeaderMessageDestinationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeMessageHeaderMessageDestinationComponentElements(MessageHeader.MessageDestinationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTarget()) {
- composeReference("target", element.getTarget());
- }
- if (element.hasEndpointElement()) {
- composeUri("endpoint", element.getEndpointElement());
- }
- }
-
- protected void composeModuleDefinition(String name, ModuleDefinition element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleDefinitionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleDefinitionElements(ModuleDefinition element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasModel()) {
- for (ModuleDefinition.ModuleDefinitionModelComponent e : element.getModel())
- composeModuleDefinitionModuleDefinitionModelComponent("model", e);
- }
- if (element.hasLibrary()) {
- for (ModuleDefinition.ModuleDefinitionLibraryComponent e : element.getLibrary())
- composeModuleDefinitionModuleDefinitionLibraryComponent("library", e);
- }
- if (element.hasCodeSystem()) {
- for (ModuleDefinition.ModuleDefinitionCodeSystemComponent e : element.getCodeSystem())
- composeModuleDefinitionModuleDefinitionCodeSystemComponent("codeSystem", e);
- }
- if (element.hasValueSet()) {
- for (ModuleDefinition.ModuleDefinitionValueSetComponent e : element.getValueSet())
- composeModuleDefinitionModuleDefinitionValueSetComponent("valueSet", e);
- }
- if (element.hasParameter()) {
- for (ModuleDefinition.ModuleDefinitionParameterComponent e : element.getParameter())
- composeModuleDefinitionModuleDefinitionParameterComponent("parameter", e);
- }
- if (element.hasData()) {
- for (ModuleDefinition.ModuleDefinitionDataComponent e : element.getData())
- composeModuleDefinitionModuleDefinitionDataComponent("data", e);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionModelComponent(String name, ModuleDefinition.ModuleDefinitionModelComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleDefinitionModuleDefinitionModelComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionModelComponentElements(ModuleDefinition.ModuleDefinitionModelComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasIdentifierElement()) {
- composeString("identifier", element.getIdentifierElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionLibraryComponent(String name, ModuleDefinition.ModuleDefinitionLibraryComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleDefinitionModuleDefinitionLibraryComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionLibraryComponentElements(ModuleDefinition.ModuleDefinitionLibraryComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasIdentifierElement()) {
- composeString("identifier", element.getIdentifierElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasDocument()) {
- composeType("document", element.getDocument());
- } }
-
- protected void composeModuleDefinitionModuleDefinitionCodeSystemComponent(String name, ModuleDefinition.ModuleDefinitionCodeSystemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleDefinitionModuleDefinitionCodeSystemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionCodeSystemComponentElements(ModuleDefinition.ModuleDefinitionCodeSystemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasIdentifierElement()) {
- composeString("identifier", element.getIdentifierElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionValueSetComponent(String name, ModuleDefinition.ModuleDefinitionValueSetComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleDefinitionModuleDefinitionValueSetComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionValueSetComponentElements(ModuleDefinition.ModuleDefinitionValueSetComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasIdentifierElement()) {
- composeString("identifier", element.getIdentifierElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasCodeSystem()) {
- for (StringType e : element.getCodeSystem())
- composeString("codeSystem", e);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionParameterComponent(String name, ModuleDefinition.ModuleDefinitionParameterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleDefinitionModuleDefinitionParameterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionParameterComponentElements(ModuleDefinition.ModuleDefinitionParameterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeCode("name", element.getNameElement());
- }
- if (element.hasUseElement()) {
- composeCode("use", element.getUseElement());
- }
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- if (element.hasTypeElement()) {
- composeCode("type", element.getTypeElement());
- }
- if (element.hasProfile()) {
- composeReference("profile", element.getProfile());
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionDataComponent(String name, ModuleDefinition.ModuleDefinitionDataComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleDefinitionModuleDefinitionDataComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionDataComponentElements(ModuleDefinition.ModuleDefinitionDataComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement()) {
- composeCode("type", element.getTypeElement());
- }
- if (element.hasProfile()) {
- composeReference("profile", element.getProfile());
- }
- if (element.hasMustSupport()) {
- for (StringType e : element.getMustSupport())
- composeString("mustSupport", e);
- }
- if (element.hasCodeFilter()) {
- for (ModuleDefinition.ModuleDefinitionDataCodeFilterComponent e : element.getCodeFilter())
- composeModuleDefinitionModuleDefinitionDataCodeFilterComponent("codeFilter", e);
- }
- if (element.hasDateFilter()) {
- for (ModuleDefinition.ModuleDefinitionDataDateFilterComponent e : element.getDateFilter())
- composeModuleDefinitionModuleDefinitionDataDateFilterComponent("dateFilter", e);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionDataCodeFilterComponent(String name, ModuleDefinition.ModuleDefinitionDataCodeFilterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleDefinitionModuleDefinitionDataCodeFilterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionDataCodeFilterComponentElements(ModuleDefinition.ModuleDefinitionDataCodeFilterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasPathElement()) {
- composeString("path", element.getPathElement());
- }
- if (element.hasValueSet()) {
- composeType("valueSet", element.getValueSet());
- } if (element.hasCodeableConcept()) {
- for (CodeableConcept e : element.getCodeableConcept())
- composeCodeableConcept("codeableConcept", e);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionDataDateFilterComponent(String name, ModuleDefinition.ModuleDefinitionDataDateFilterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeModuleDefinitionModuleDefinitionDataDateFilterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeModuleDefinitionModuleDefinitionDataDateFilterComponentElements(ModuleDefinition.ModuleDefinitionDataDateFilterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasPathElement()) {
- composeString("path", element.getPathElement());
- }
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeNamingSystem(String name, NamingSystem element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeNamingSystemElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeNamingSystemElements(NamingSystem element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasKindElement())
- composeEnumeration("kind", element.getKindElement(), new NamingSystem.NamingSystemTypeEnumFactory());
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (NamingSystem.NamingSystemContactComponent e : element.getContact())
- composeNamingSystemNamingSystemContactComponent("contact", e);
- }
- if (element.hasResponsibleElement()) {
- composeString("responsible", element.getResponsibleElement());
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasUsageElement()) {
- composeString("usage", element.getUsageElement());
- }
- if (element.hasUniqueId()) {
- for (NamingSystem.NamingSystemUniqueIdComponent e : element.getUniqueId())
- composeNamingSystemNamingSystemUniqueIdComponent("uniqueId", e);
- }
- if (element.hasReplacedBy()) {
- composeReference("replacedBy", element.getReplacedBy());
- }
- }
-
- protected void composeNamingSystemNamingSystemContactComponent(String name, NamingSystem.NamingSystemContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeNamingSystemNamingSystemContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeNamingSystemNamingSystemContactComponentElements(NamingSystem.NamingSystemContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeNamingSystemNamingSystemUniqueIdComponent(String name, NamingSystem.NamingSystemUniqueIdComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeNamingSystemNamingSystemUniqueIdComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeNamingSystemNamingSystemUniqueIdComponentElements(NamingSystem.NamingSystemUniqueIdComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new NamingSystem.NamingSystemIdentifierTypeEnumFactory());
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- if (element.hasPreferredElement()) {
- composeBoolean("preferred", element.getPreferredElement());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composeNutritionOrder(String name, NutritionOrder element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeNutritionOrderElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeNutritionOrderElements(NutritionOrder element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new NutritionOrder.NutritionOrderStatusEnumFactory());
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasDateTimeElement()) {
- composeDateTime("dateTime", element.getDateTimeElement());
- }
- if (element.hasOrderer()) {
- composeReference("orderer", element.getOrderer());
- }
- if (element.hasAllergyIntolerance()) {
- for (Reference e : element.getAllergyIntolerance())
- composeReference("allergyIntolerance", e);
- }
- if (element.hasFoodPreferenceModifier()) {
- for (CodeableConcept e : element.getFoodPreferenceModifier())
- composeCodeableConcept("foodPreferenceModifier", e);
- }
- if (element.hasExcludeFoodModifier()) {
- for (CodeableConcept e : element.getExcludeFoodModifier())
- composeCodeableConcept("excludeFoodModifier", e);
- }
- if (element.hasOralDiet()) {
- composeNutritionOrderNutritionOrderOralDietComponent("oralDiet", element.getOralDiet());
- }
- if (element.hasSupplement()) {
- for (NutritionOrder.NutritionOrderSupplementComponent e : element.getSupplement())
- composeNutritionOrderNutritionOrderSupplementComponent("supplement", e);
- }
- if (element.hasEnteralFormula()) {
- composeNutritionOrderNutritionOrderEnteralFormulaComponent("enteralFormula", element.getEnteralFormula());
- }
- }
-
- protected void composeNutritionOrderNutritionOrderOralDietComponent(String name, NutritionOrder.NutritionOrderOralDietComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeNutritionOrderNutritionOrderOralDietComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeNutritionOrderNutritionOrderOralDietComponentElements(NutritionOrder.NutritionOrderOralDietComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- for (CodeableConcept e : element.getType())
- composeCodeableConcept("type", e);
- }
- if (element.hasSchedule()) {
- for (Timing e : element.getSchedule())
- composeTiming("schedule", e);
- }
- if (element.hasNutrient()) {
- for (NutritionOrder.NutritionOrderOralDietNutrientComponent e : element.getNutrient())
- composeNutritionOrderNutritionOrderOralDietNutrientComponent("nutrient", e);
- }
- if (element.hasTexture()) {
- for (NutritionOrder.NutritionOrderOralDietTextureComponent e : element.getTexture())
- composeNutritionOrderNutritionOrderOralDietTextureComponent("texture", e);
- }
- if (element.hasFluidConsistencyType()) {
- for (CodeableConcept e : element.getFluidConsistencyType())
- composeCodeableConcept("fluidConsistencyType", e);
- }
- if (element.hasInstructionElement()) {
- composeString("instruction", element.getInstructionElement());
- }
- }
-
- protected void composeNutritionOrderNutritionOrderOralDietNutrientComponent(String name, NutritionOrder.NutritionOrderOralDietNutrientComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeNutritionOrderNutritionOrderOralDietNutrientComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeNutritionOrderNutritionOrderOralDietNutrientComponentElements(NutritionOrder.NutritionOrderOralDietNutrientComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasModifier()) {
- composeCodeableConcept("modifier", element.getModifier());
- }
- if (element.hasAmount()) {
- composeSimpleQuantity("amount", element.getAmount());
- }
- }
-
- protected void composeNutritionOrderNutritionOrderOralDietTextureComponent(String name, NutritionOrder.NutritionOrderOralDietTextureComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeNutritionOrderNutritionOrderOralDietTextureComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeNutritionOrderNutritionOrderOralDietTextureComponentElements(NutritionOrder.NutritionOrderOralDietTextureComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasModifier()) {
- composeCodeableConcept("modifier", element.getModifier());
- }
- if (element.hasFoodType()) {
- composeCodeableConcept("foodType", element.getFoodType());
- }
- }
-
- protected void composeNutritionOrderNutritionOrderSupplementComponent(String name, NutritionOrder.NutritionOrderSupplementComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeNutritionOrderNutritionOrderSupplementComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeNutritionOrderNutritionOrderSupplementComponentElements(NutritionOrder.NutritionOrderSupplementComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasProductNameElement()) {
- composeString("productName", element.getProductNameElement());
- }
- if (element.hasSchedule()) {
- for (Timing e : element.getSchedule())
- composeTiming("schedule", e);
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasInstructionElement()) {
- composeString("instruction", element.getInstructionElement());
- }
- }
-
- protected void composeNutritionOrderNutritionOrderEnteralFormulaComponent(String name, NutritionOrder.NutritionOrderEnteralFormulaComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeNutritionOrderNutritionOrderEnteralFormulaComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeNutritionOrderNutritionOrderEnteralFormulaComponentElements(NutritionOrder.NutritionOrderEnteralFormulaComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasBaseFormulaType()) {
- composeCodeableConcept("baseFormulaType", element.getBaseFormulaType());
- }
- if (element.hasBaseFormulaProductNameElement()) {
- composeString("baseFormulaProductName", element.getBaseFormulaProductNameElement());
- }
- if (element.hasAdditiveType()) {
- composeCodeableConcept("additiveType", element.getAdditiveType());
- }
- if (element.hasAdditiveProductNameElement()) {
- composeString("additiveProductName", element.getAdditiveProductNameElement());
- }
- if (element.hasCaloricDensity()) {
- composeSimpleQuantity("caloricDensity", element.getCaloricDensity());
- }
- if (element.hasRouteofAdministration()) {
- composeCodeableConcept("routeofAdministration", element.getRouteofAdministration());
- }
- if (element.hasAdministration()) {
- for (NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent e : element.getAdministration())
- composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent("administration", e);
- }
- if (element.hasMaxVolumeToDeliver()) {
- composeSimpleQuantity("maxVolumeToDeliver", element.getMaxVolumeToDeliver());
- }
- if (element.hasAdministrationInstructionElement()) {
- composeString("administrationInstruction", element.getAdministrationInstructionElement());
- }
- }
-
- protected void composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponent(String name, NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeNutritionOrderNutritionOrderEnteralFormulaAdministrationComponentElements(NutritionOrder.NutritionOrderEnteralFormulaAdministrationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSchedule()) {
- composeTiming("schedule", element.getSchedule());
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasRate()) {
- composeType("rate", element.getRate());
- } }
-
- protected void composeObservation(String name, Observation element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeObservationElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeObservationElements(Observation element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Observation.ObservationStatusEnumFactory());
- if (element.hasCategory()) {
- for (CodeableConcept e : element.getCategory())
- composeCodeableConcept("category", e);
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasEffective()) {
- composeType("effective", element.getEffective());
- } if (element.hasIssuedElement()) {
- composeInstant("issued", element.getIssuedElement());
- }
- if (element.hasPerformer()) {
- for (Reference e : element.getPerformer())
- composeReference("performer", e);
- }
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } if (element.hasDataAbsentReason()) {
- composeCodeableConcept("dataAbsentReason", element.getDataAbsentReason());
- }
- if (element.hasInterpretation()) {
- composeCodeableConcept("interpretation", element.getInterpretation());
- }
- if (element.hasCommentElement()) {
- composeString("comment", element.getCommentElement());
- }
- if (element.hasBodySite()) {
- composeCodeableConcept("bodySite", element.getBodySite());
- }
- if (element.hasMethod()) {
- composeCodeableConcept("method", element.getMethod());
- }
- if (element.hasSpecimen()) {
- composeReference("specimen", element.getSpecimen());
- }
- if (element.hasDevice()) {
- composeReference("device", element.getDevice());
- }
- if (element.hasReferenceRange()) {
- for (Observation.ObservationReferenceRangeComponent e : element.getReferenceRange())
- composeObservationObservationReferenceRangeComponent("referenceRange", e);
- }
- if (element.hasRelated()) {
- for (Observation.ObservationRelatedComponent e : element.getRelated())
- composeObservationObservationRelatedComponent("related", e);
- }
- if (element.hasComponent()) {
- for (Observation.ObservationComponentComponent e : element.getComponent())
- composeObservationObservationComponentComponent("component", e);
- }
- }
-
- protected void composeObservationObservationReferenceRangeComponent(String name, Observation.ObservationReferenceRangeComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeObservationObservationReferenceRangeComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeObservationObservationReferenceRangeComponentElements(Observation.ObservationReferenceRangeComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLow()) {
- composeSimpleQuantity("low", element.getLow());
- }
- if (element.hasHigh()) {
- composeSimpleQuantity("high", element.getHigh());
- }
- if (element.hasMeaning()) {
- for (CodeableConcept e : element.getMeaning())
- composeCodeableConcept("meaning", e);
- }
- if (element.hasAge()) {
- composeRange("age", element.getAge());
- }
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- }
-
- protected void composeObservationObservationRelatedComponent(String name, Observation.ObservationRelatedComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeObservationObservationRelatedComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeObservationObservationRelatedComponentElements(Observation.ObservationRelatedComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Observation.ObservationRelationshipTypeEnumFactory());
- if (element.hasTarget()) {
- composeReference("target", element.getTarget());
- }
- }
-
- protected void composeObservationObservationComponentComponent(String name, Observation.ObservationComponentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeObservationObservationComponentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeObservationObservationComponentComponentElements(Observation.ObservationComponentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } if (element.hasDataAbsentReason()) {
- composeCodeableConcept("dataAbsentReason", element.getDataAbsentReason());
- }
- if (element.hasInterpretation()) {
- composeCodeableConcept("interpretation", element.getInterpretation());
- }
- if (element.hasReferenceRange()) {
- for (Observation.ObservationReferenceRangeComponent e : element.getReferenceRange())
- composeObservationObservationReferenceRangeComponent("referenceRange", e);
- }
- }
-
- protected void composeOperationDefinition(String name, OperationDefinition element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOperationDefinitionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOperationDefinitionElements(OperationDefinition element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasKindElement())
- composeEnumeration("kind", element.getKindElement(), new OperationDefinition.OperationKindEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (OperationDefinition.OperationDefinitionContactComponent e : element.getContact())
- composeOperationDefinitionOperationDefinitionContactComponent("contact", e);
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasRequirementsElement()) {
- composeString("requirements", element.getRequirementsElement());
- }
- if (element.hasIdempotentElement()) {
- composeBoolean("idempotent", element.getIdempotentElement());
- }
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasCommentElement()) {
- composeString("comment", element.getCommentElement());
- }
- if (element.hasBase()) {
- composeReference("base", element.getBase());
- }
- if (element.hasSystemElement()) {
- composeBoolean("system", element.getSystemElement());
- }
- if (element.hasType()) {
- for (CodeType e : element.getType())
- composeCode("type", e);
- }
- if (element.hasInstanceElement()) {
- composeBoolean("instance", element.getInstanceElement());
- }
- if (element.hasParameter()) {
- for (OperationDefinition.OperationDefinitionParameterComponent e : element.getParameter())
- composeOperationDefinitionOperationDefinitionParameterComponent("parameter", e);
- }
- }
-
- protected void composeOperationDefinitionOperationDefinitionContactComponent(String name, OperationDefinition.OperationDefinitionContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOperationDefinitionOperationDefinitionContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOperationDefinitionOperationDefinitionContactComponentElements(OperationDefinition.OperationDefinitionContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeOperationDefinitionOperationDefinitionParameterComponent(String name, OperationDefinition.OperationDefinitionParameterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOperationDefinitionOperationDefinitionParameterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOperationDefinitionOperationDefinitionParameterComponentElements(OperationDefinition.OperationDefinitionParameterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeCode("name", element.getNameElement());
- }
- if (element.hasUseElement())
- composeEnumeration("use", element.getUseElement(), new OperationDefinition.OperationParameterUseEnumFactory());
- if (element.hasMinElement()) {
- composeInteger("min", element.getMinElement());
- }
- if (element.hasMaxElement()) {
- composeString("max", element.getMaxElement());
- }
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- if (element.hasTypeElement()) {
- composeCode("type", element.getTypeElement());
- }
- if (element.hasSearchTypeElement())
- composeEnumeration("searchType", element.getSearchTypeElement(), new Enumerations.SearchParamTypeEnumFactory());
- if (element.hasProfile()) {
- composeReference("profile", element.getProfile());
- }
- if (element.hasBinding()) {
- composeOperationDefinitionOperationDefinitionParameterBindingComponent("binding", element.getBinding());
- }
- if (element.hasPart()) {
- for (OperationDefinition.OperationDefinitionParameterComponent e : element.getPart())
- composeOperationDefinitionOperationDefinitionParameterComponent("part", e);
- }
- }
-
- protected void composeOperationDefinitionOperationDefinitionParameterBindingComponent(String name, OperationDefinition.OperationDefinitionParameterBindingComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOperationDefinitionOperationDefinitionParameterBindingComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOperationDefinitionOperationDefinitionParameterBindingComponentElements(OperationDefinition.OperationDefinitionParameterBindingComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStrengthElement())
- composeEnumeration("strength", element.getStrengthElement(), new Enumerations.BindingStrengthEnumFactory());
- if (element.hasValueSet()) {
- composeType("valueSet", element.getValueSet());
- } }
-
- protected void composeOperationOutcome(String name, OperationOutcome element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOperationOutcomeElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOperationOutcomeElements(OperationOutcome element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIssue()) {
- for (OperationOutcome.OperationOutcomeIssueComponent e : element.getIssue())
- composeOperationOutcomeOperationOutcomeIssueComponent("issue", e);
- }
- }
-
- protected void composeOperationOutcomeOperationOutcomeIssueComponent(String name, OperationOutcome.OperationOutcomeIssueComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOperationOutcomeOperationOutcomeIssueComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOperationOutcomeOperationOutcomeIssueComponentElements(OperationOutcome.OperationOutcomeIssueComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSeverityElement())
- composeEnumeration("severity", element.getSeverityElement(), new OperationOutcome.IssueSeverityEnumFactory());
- if (element.hasCodeElement())
- composeEnumeration("code", element.getCodeElement(), new OperationOutcome.IssueTypeEnumFactory());
- if (element.hasDetails()) {
- composeCodeableConcept("details", element.getDetails());
- }
- if (element.hasDiagnosticsElement()) {
- composeString("diagnostics", element.getDiagnosticsElement());
- }
- if (element.hasLocation()) {
- for (StringType e : element.getLocation())
- composeString("location", e);
- }
- if (element.hasExpression()) {
- for (StringType e : element.getExpression())
- composeString("expression", e);
- }
- }
-
- protected void composeOrder(String name, Order element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOrderElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOrderElements(Order element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasSource()) {
- composeReference("source", element.getSource());
- }
- if (element.hasTarget()) {
- composeReference("target", element.getTarget());
- }
- if (element.hasReason()) {
- composeType("reason", element.getReason());
- } if (element.hasWhen()) {
- composeOrderOrderWhenComponent("when", element.getWhen());
- }
- if (element.hasDetail()) {
- for (Reference e : element.getDetail())
- composeReference("detail", e);
- }
- }
-
- protected void composeOrderOrderWhenComponent(String name, Order.OrderWhenComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOrderOrderWhenComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOrderOrderWhenComponentElements(Order.OrderWhenComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasSchedule()) {
- composeTiming("schedule", element.getSchedule());
- }
- }
-
- protected void composeOrderResponse(String name, OrderResponse element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOrderResponseElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOrderResponseElements(OrderResponse element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasRequest()) {
- composeReference("request", element.getRequest());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasWho()) {
- composeReference("who", element.getWho());
- }
- if (element.hasOrderStatusElement())
- composeEnumeration("orderStatus", element.getOrderStatusElement(), new OrderResponse.OrderStatusEnumFactory());
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasFulfillment()) {
- for (Reference e : element.getFulfillment())
- composeReference("fulfillment", e);
- }
- }
-
- protected void composeOrderSet(String name, OrderSet element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOrderSetElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOrderSetElements(OrderSet element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasModuleMetadata()) {
- composeModuleMetadata("moduleMetadata", element.getModuleMetadata());
- }
- if (element.hasLibrary()) {
- for (Reference e : element.getLibrary())
- composeReference("library", e);
- }
- if (element.hasAction()) {
- for (ActionDefinition e : element.getAction())
- composeActionDefinition("action", e);
- }
- }
-
- protected void composeOrganization(String name, Organization element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOrganizationElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOrganizationElements(Organization element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasActiveElement()) {
- composeBoolean("active", element.getActiveElement());
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasAddress()) {
- for (Address e : element.getAddress())
- composeAddress("address", e);
- }
- if (element.hasPartOf()) {
- composeReference("partOf", element.getPartOf());
- }
- if (element.hasContact()) {
- for (Organization.OrganizationContactComponent e : element.getContact())
- composeOrganizationOrganizationContactComponent("contact", e);
- }
- }
-
- protected void composeOrganizationOrganizationContactComponent(String name, Organization.OrganizationContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeOrganizationOrganizationContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeOrganizationOrganizationContactComponentElements(Organization.OrganizationContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasPurpose()) {
- composeCodeableConcept("purpose", element.getPurpose());
- }
- if (element.hasName()) {
- composeHumanName("name", element.getName());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasAddress()) {
- composeAddress("address", element.getAddress());
- }
- }
-
- protected void composePatient(String name, Patient element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composePatientElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePatientElements(Patient element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasActiveElement()) {
- composeBoolean("active", element.getActiveElement());
- }
- if (element.hasName()) {
- for (HumanName e : element.getName())
- composeHumanName("name", e);
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasGenderElement())
- composeEnumeration("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory());
- if (element.hasBirthDateElement()) {
- composeDate("birthDate", element.getBirthDateElement());
- }
- if (element.hasDeceased()) {
- composeType("deceased", element.getDeceased());
- } if (element.hasAddress()) {
- for (Address e : element.getAddress())
- composeAddress("address", e);
- }
- if (element.hasMaritalStatus()) {
- composeCodeableConcept("maritalStatus", element.getMaritalStatus());
- }
- if (element.hasMultipleBirth()) {
- composeType("multipleBirth", element.getMultipleBirth());
- } if (element.hasPhoto()) {
- for (Attachment e : element.getPhoto())
- composeAttachment("photo", e);
- }
- if (element.hasContact()) {
- for (Patient.ContactComponent e : element.getContact())
- composePatientContactComponent("contact", e);
- }
- if (element.hasAnimal()) {
- composePatientAnimalComponent("animal", element.getAnimal());
- }
- if (element.hasCommunication()) {
- for (Patient.PatientCommunicationComponent e : element.getCommunication())
- composePatientPatientCommunicationComponent("communication", e);
- }
- if (element.hasCareProvider()) {
- for (Reference e : element.getCareProvider())
- composeReference("careProvider", e);
- }
- if (element.hasManagingOrganization()) {
- composeReference("managingOrganization", element.getManagingOrganization());
- }
- if (element.hasLink()) {
- for (Patient.PatientLinkComponent e : element.getLink())
- composePatientPatientLinkComponent("link", e);
- }
- }
-
- protected void composePatientContactComponent(String name, Patient.ContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composePatientContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePatientContactComponentElements(Patient.ContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRelationship()) {
- for (CodeableConcept e : element.getRelationship())
- composeCodeableConcept("relationship", e);
- }
- if (element.hasName()) {
- composeHumanName("name", element.getName());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasAddress()) {
- composeAddress("address", element.getAddress());
- }
- if (element.hasGenderElement())
- composeEnumeration("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory());
- if (element.hasOrganization()) {
- composeReference("organization", element.getOrganization());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composePatientAnimalComponent(String name, Patient.AnimalComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composePatientAnimalComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePatientAnimalComponentElements(Patient.AnimalComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSpecies()) {
- composeCodeableConcept("species", element.getSpecies());
- }
- if (element.hasBreed()) {
- composeCodeableConcept("breed", element.getBreed());
- }
- if (element.hasGenderStatus()) {
- composeCodeableConcept("genderStatus", element.getGenderStatus());
- }
- }
-
- protected void composePatientPatientCommunicationComponent(String name, Patient.PatientCommunicationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composePatientPatientCommunicationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePatientPatientCommunicationComponentElements(Patient.PatientCommunicationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLanguage()) {
- composeCodeableConcept("language", element.getLanguage());
- }
- if (element.hasPreferredElement()) {
- composeBoolean("preferred", element.getPreferredElement());
- }
- }
-
- protected void composePatientPatientLinkComponent(String name, Patient.PatientLinkComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composePatientPatientLinkComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePatientPatientLinkComponentElements(Patient.PatientLinkComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasOther()) {
- composeReference("other", element.getOther());
- }
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Patient.LinkTypeEnumFactory());
- }
-
- protected void composePaymentNotice(String name, PaymentNotice element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composePaymentNoticeElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePaymentNoticeElements(PaymentNotice element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasRuleset()) {
- composeCoding("ruleset", element.getRuleset());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasTarget()) {
- composeType("target", element.getTarget());
- } if (element.hasProvider()) {
- composeType("provider", element.getProvider());
- } if (element.hasOrganization()) {
- composeType("organization", element.getOrganization());
- } if (element.hasRequest()) {
- composeType("request", element.getRequest());
- } if (element.hasResponse()) {
- composeType("response", element.getResponse());
- } if (element.hasPaymentStatus()) {
- composeCoding("paymentStatus", element.getPaymentStatus());
- }
- if (element.hasStatusDateElement()) {
- composeDate("statusDate", element.getStatusDateElement());
- }
- }
-
- protected void composePaymentReconciliation(String name, PaymentReconciliation element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composePaymentReconciliationElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePaymentReconciliationElements(PaymentReconciliation element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasRequest()) {
- composeType("request", element.getRequest());
- } if (element.hasOutcomeElement())
- composeEnumeration("outcome", element.getOutcomeElement(), new Enumerations.RemittanceOutcomeEnumFactory());
- if (element.hasDispositionElement()) {
- composeString("disposition", element.getDispositionElement());
- }
- if (element.hasRuleset()) {
- composeCoding("ruleset", element.getRuleset());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasOrganization()) {
- composeType("organization", element.getOrganization());
- } if (element.hasRequestProvider()) {
- composeType("requestProvider", element.getRequestProvider());
- } if (element.hasRequestOrganization()) {
- composeType("requestOrganization", element.getRequestOrganization());
- } if (element.hasDetail()) {
- for (PaymentReconciliation.DetailsComponent e : element.getDetail())
- composePaymentReconciliationDetailsComponent("detail", e);
- }
- if (element.hasForm()) {
- composeCoding("form", element.getForm());
- }
- if (element.hasTotal()) {
- composeMoney("total", element.getTotal());
- }
- if (element.hasNote()) {
- for (PaymentReconciliation.NotesComponent e : element.getNote())
- composePaymentReconciliationNotesComponent("note", e);
- }
- }
-
- protected void composePaymentReconciliationDetailsComponent(String name, PaymentReconciliation.DetailsComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composePaymentReconciliationDetailsComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePaymentReconciliationDetailsComponentElements(PaymentReconciliation.DetailsComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasRequest()) {
- composeType("request", element.getRequest());
- } if (element.hasResponce()) {
- composeType("responce", element.getResponce());
- } if (element.hasSubmitter()) {
- composeType("submitter", element.getSubmitter());
- } if (element.hasPayee()) {
- composeType("payee", element.getPayee());
- } if (element.hasDateElement()) {
- composeDate("date", element.getDateElement());
- }
- if (element.hasAmount()) {
- composeMoney("amount", element.getAmount());
- }
- }
-
- protected void composePaymentReconciliationNotesComponent(String name, PaymentReconciliation.NotesComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composePaymentReconciliationNotesComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePaymentReconciliationNotesComponentElements(PaymentReconciliation.NotesComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- }
-
- protected void composePerson(String name, Person element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composePersonElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePersonElements(Person element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasName()) {
- for (HumanName e : element.getName())
- composeHumanName("name", e);
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasGenderElement())
- composeEnumeration("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory());
- if (element.hasBirthDateElement()) {
- composeDate("birthDate", element.getBirthDateElement());
- }
- if (element.hasAddress()) {
- for (Address e : element.getAddress())
- composeAddress("address", e);
- }
- if (element.hasPhoto()) {
- composeAttachment("photo", element.getPhoto());
- }
- if (element.hasManagingOrganization()) {
- composeReference("managingOrganization", element.getManagingOrganization());
- }
- if (element.hasActiveElement()) {
- composeBoolean("active", element.getActiveElement());
- }
- if (element.hasLink()) {
- for (Person.PersonLinkComponent e : element.getLink())
- composePersonPersonLinkComponent("link", e);
- }
- }
-
- protected void composePersonPersonLinkComponent(String name, Person.PersonLinkComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composePersonPersonLinkComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePersonPersonLinkComponentElements(Person.PersonLinkComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTarget()) {
- composeReference("target", element.getTarget());
- }
- if (element.hasAssuranceElement())
- composeEnumeration("assurance", element.getAssuranceElement(), new Person.IdentityAssuranceLevelEnumFactory());
- }
-
- protected void composePractitioner(String name, Practitioner element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composePractitionerElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePractitionerElements(Practitioner element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasActiveElement()) {
- composeBoolean("active", element.getActiveElement());
- }
- if (element.hasName()) {
- for (HumanName e : element.getName())
- composeHumanName("name", e);
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasAddress()) {
- for (Address e : element.getAddress())
- composeAddress("address", e);
- }
- if (element.hasGenderElement())
- composeEnumeration("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory());
- if (element.hasBirthDateElement()) {
- composeDate("birthDate", element.getBirthDateElement());
- }
- if (element.hasPhoto()) {
- for (Attachment e : element.getPhoto())
- composeAttachment("photo", e);
- }
- if (element.hasPractitionerRole()) {
- for (Practitioner.PractitionerPractitionerRoleComponent e : element.getPractitionerRole())
- composePractitionerPractitionerPractitionerRoleComponent("practitionerRole", e);
- }
- if (element.hasQualification()) {
- for (Practitioner.PractitionerQualificationComponent e : element.getQualification())
- composePractitionerPractitionerQualificationComponent("qualification", e);
- }
- if (element.hasCommunication()) {
- for (CodeableConcept e : element.getCommunication())
- composeCodeableConcept("communication", e);
- }
- }
-
- protected void composePractitionerPractitionerPractitionerRoleComponent(String name, Practitioner.PractitionerPractitionerRoleComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composePractitionerPractitionerPractitionerRoleComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePractitionerPractitionerPractitionerRoleComponentElements(Practitioner.PractitionerPractitionerRoleComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasOrganization()) {
- composeReference("organization", element.getOrganization());
- }
- if (element.hasRole()) {
- composeCodeableConcept("role", element.getRole());
- }
- if (element.hasSpecialty()) {
- for (CodeableConcept e : element.getSpecialty())
- composeCodeableConcept("specialty", e);
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasLocation()) {
- for (Reference e : element.getLocation())
- composeReference("location", e);
- }
- if (element.hasHealthcareService()) {
- for (Reference e : element.getHealthcareService())
- composeReference("healthcareService", e);
- }
- }
-
- protected void composePractitionerPractitionerQualificationComponent(String name, Practitioner.PractitionerQualificationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composePractitionerPractitionerQualificationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePractitionerPractitionerQualificationComponentElements(Practitioner.PractitionerQualificationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasIssuer()) {
- composeReference("issuer", element.getIssuer());
- }
- }
-
- protected void composePractitionerRole(String name, PractitionerRole element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composePractitionerRoleElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePractitionerRoleElements(PractitionerRole element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasActiveElement()) {
- composeBoolean("active", element.getActiveElement());
- }
- if (element.hasPractitioner()) {
- composeReference("practitioner", element.getPractitioner());
- }
- if (element.hasOrganization()) {
- composeReference("organization", element.getOrganization());
- }
- if (element.hasRole()) {
- for (CodeableConcept e : element.getRole())
- composeCodeableConcept("role", e);
- }
- if (element.hasSpecialty()) {
- for (CodeableConcept e : element.getSpecialty())
- composeCodeableConcept("specialty", e);
- }
- if (element.hasLocation()) {
- for (Reference e : element.getLocation())
- composeReference("location", e);
- }
- if (element.hasHealthcareService()) {
- for (Reference e : element.getHealthcareService())
- composeReference("healthcareService", e);
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasAvailableTime()) {
- for (PractitionerRole.PractitionerRoleAvailableTimeComponent e : element.getAvailableTime())
- composePractitionerRolePractitionerRoleAvailableTimeComponent("availableTime", e);
- }
- if (element.hasNotAvailable()) {
- for (PractitionerRole.PractitionerRoleNotAvailableComponent e : element.getNotAvailable())
- composePractitionerRolePractitionerRoleNotAvailableComponent("notAvailable", e);
- }
- if (element.hasAvailabilityExceptionsElement()) {
- composeString("availabilityExceptions", element.getAvailabilityExceptionsElement());
- }
- }
-
- protected void composePractitionerRolePractitionerRoleAvailableTimeComponent(String name, PractitionerRole.PractitionerRoleAvailableTimeComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composePractitionerRolePractitionerRoleAvailableTimeComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePractitionerRolePractitionerRoleAvailableTimeComponentElements(PractitionerRole.PractitionerRoleAvailableTimeComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDaysOfWeek()) {
- for (CodeType e : element.getDaysOfWeek())
- composeCode("daysOfWeek", e);
- }
- if (element.hasAllDayElement()) {
- composeBoolean("allDay", element.getAllDayElement());
- }
- if (element.hasAvailableStartTimeElement()) {
- composeTime("availableStartTime", element.getAvailableStartTimeElement());
- }
- if (element.hasAvailableEndTimeElement()) {
- composeTime("availableEndTime", element.getAvailableEndTimeElement());
- }
- }
-
- protected void composePractitionerRolePractitionerRoleNotAvailableComponent(String name, PractitionerRole.PractitionerRoleNotAvailableComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composePractitionerRolePractitionerRoleNotAvailableComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composePractitionerRolePractitionerRoleNotAvailableComponentElements(PractitionerRole.PractitionerRoleNotAvailableComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasDuring()) {
- composePeriod("during", element.getDuring());
- }
- }
-
- protected void composeProcedure(String name, Procedure element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProcedureElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProcedureElements(Procedure element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Procedure.ProcedureStatusEnumFactory());
- if (element.hasCategory()) {
- composeCodeableConcept("category", element.getCategory());
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasNotPerformedElement()) {
- composeBoolean("notPerformed", element.getNotPerformedElement());
- }
- if (element.hasReasonNotPerformed()) {
- for (CodeableConcept e : element.getReasonNotPerformed())
- composeCodeableConcept("reasonNotPerformed", e);
- }
- if (element.hasBodySite()) {
- for (CodeableConcept e : element.getBodySite())
- composeCodeableConcept("bodySite", e);
- }
- if (element.hasReason()) {
- composeType("reason", element.getReason());
- } if (element.hasPerformer()) {
- for (Procedure.ProcedurePerformerComponent e : element.getPerformer())
- composeProcedureProcedurePerformerComponent("performer", e);
- }
- if (element.hasPerformed()) {
- composeType("performed", element.getPerformed());
- } if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasLocation()) {
- composeReference("location", element.getLocation());
- }
- if (element.hasOutcome()) {
- composeCodeableConcept("outcome", element.getOutcome());
- }
- if (element.hasReport()) {
- for (Reference e : element.getReport())
- composeReference("report", e);
- }
- if (element.hasComplication()) {
- for (CodeableConcept e : element.getComplication())
- composeCodeableConcept("complication", e);
- }
- if (element.hasFollowUp()) {
- for (CodeableConcept e : element.getFollowUp())
- composeCodeableConcept("followUp", e);
- }
- if (element.hasRequest()) {
- composeReference("request", element.getRequest());
- }
- if (element.hasNotes()) {
- for (Annotation e : element.getNotes())
- composeAnnotation("notes", e);
- }
- if (element.hasFocalDevice()) {
- for (Procedure.ProcedureFocalDeviceComponent e : element.getFocalDevice())
- composeProcedureProcedureFocalDeviceComponent("focalDevice", e);
- }
- if (element.hasUsed()) {
- for (Reference e : element.getUsed())
- composeReference("used", e);
- }
- }
-
- protected void composeProcedureProcedurePerformerComponent(String name, Procedure.ProcedurePerformerComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProcedureProcedurePerformerComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProcedureProcedurePerformerComponentElements(Procedure.ProcedurePerformerComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasRole()) {
- composeCodeableConcept("role", element.getRole());
- }
- }
-
- protected void composeProcedureProcedureFocalDeviceComponent(String name, Procedure.ProcedureFocalDeviceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProcedureProcedureFocalDeviceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProcedureProcedureFocalDeviceComponentElements(Procedure.ProcedureFocalDeviceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasAction()) {
- composeCodeableConcept("action", element.getAction());
- }
- if (element.hasManipulated()) {
- composeReference("manipulated", element.getManipulated());
- }
- }
-
- protected void composeProcedureRequest(String name, ProcedureRequest element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProcedureRequestElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProcedureRequestElements(ProcedureRequest element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasBodySite()) {
- for (CodeableConcept e : element.getBodySite())
- composeCodeableConcept("bodySite", e);
- }
- if (element.hasReason()) {
- composeType("reason", element.getReason());
- } if (element.hasScheduled()) {
- composeType("scheduled", element.getScheduled());
- } if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasPerformer()) {
- composeReference("performer", element.getPerformer());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new ProcedureRequest.ProcedureRequestStatusEnumFactory());
- if (element.hasNotes()) {
- for (Annotation e : element.getNotes())
- composeAnnotation("notes", e);
- }
- if (element.hasAsNeeded()) {
- composeType("asNeeded", element.getAsNeeded());
- } if (element.hasOrderedOnElement()) {
- composeDateTime("orderedOn", element.getOrderedOnElement());
- }
- if (element.hasOrderer()) {
- composeReference("orderer", element.getOrderer());
- }
- if (element.hasPriorityElement())
- composeEnumeration("priority", element.getPriorityElement(), new ProcedureRequest.ProcedureRequestPriorityEnumFactory());
- }
-
- protected void composeProcessRequest(String name, ProcessRequest element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProcessRequestElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProcessRequestElements(ProcessRequest element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasActionElement())
- composeEnumeration("action", element.getActionElement(), new ProcessRequest.ActionListEnumFactory());
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasRuleset()) {
- composeCoding("ruleset", element.getRuleset());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasTarget()) {
- composeType("target", element.getTarget());
- } if (element.hasProvider()) {
- composeType("provider", element.getProvider());
- } if (element.hasOrganization()) {
- composeType("organization", element.getOrganization());
- } if (element.hasRequest()) {
- composeType("request", element.getRequest());
- } if (element.hasResponse()) {
- composeType("response", element.getResponse());
- } if (element.hasNullifyElement()) {
- composeBoolean("nullify", element.getNullifyElement());
- }
- if (element.hasReferenceElement()) {
- composeString("reference", element.getReferenceElement());
- }
- if (element.hasItem()) {
- for (ProcessRequest.ItemsComponent e : element.getItem())
- composeProcessRequestItemsComponent("item", e);
- }
- if (element.hasInclude()) {
- for (StringType e : element.getInclude())
- composeString("include", e);
- }
- if (element.hasExclude()) {
- for (StringType e : element.getExclude())
- composeString("exclude", e);
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composeProcessRequestItemsComponent(String name, ProcessRequest.ItemsComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProcessRequestItemsComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProcessRequestItemsComponentElements(ProcessRequest.ItemsComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceLinkIdElement()) {
- composeInteger("sequenceLinkId", element.getSequenceLinkIdElement());
- }
- }
-
- protected void composeProcessResponse(String name, ProcessResponse element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProcessResponseElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProcessResponseElements(ProcessResponse element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasRequest()) {
- composeType("request", element.getRequest());
- } if (element.hasOutcome()) {
- composeCoding("outcome", element.getOutcome());
- }
- if (element.hasDispositionElement()) {
- composeString("disposition", element.getDispositionElement());
- }
- if (element.hasRuleset()) {
- composeCoding("ruleset", element.getRuleset());
- }
- if (element.hasOriginalRuleset()) {
- composeCoding("originalRuleset", element.getOriginalRuleset());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasOrganization()) {
- composeType("organization", element.getOrganization());
- } if (element.hasRequestProvider()) {
- composeType("requestProvider", element.getRequestProvider());
- } if (element.hasRequestOrganization()) {
- composeType("requestOrganization", element.getRequestOrganization());
- } if (element.hasForm()) {
- composeCoding("form", element.getForm());
- }
- if (element.hasNotes()) {
- for (ProcessResponse.ProcessResponseNotesComponent e : element.getNotes())
- composeProcessResponseProcessResponseNotesComponent("notes", e);
- }
- if (element.hasError()) {
- for (Coding e : element.getError())
- composeCoding("error", e);
- }
- }
-
- protected void composeProcessResponseProcessResponseNotesComponent(String name, ProcessResponse.ProcessResponseNotesComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProcessResponseProcessResponseNotesComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProcessResponseProcessResponseNotesComponentElements(ProcessResponse.ProcessResponseNotesComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- }
-
- protected void composeProtocol(String name, Protocol element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProtocolElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProtocolElements(Protocol element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasTitleElement()) {
- composeString("title", element.getTitleElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Protocol.ProtocolStatusEnumFactory());
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Protocol.ProtocolTypeEnumFactory());
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasGroup()) {
- composeReference("group", element.getGroup());
- }
- if (element.hasPurposeElement()) {
- composeString("purpose", element.getPurposeElement());
- }
- if (element.hasAuthor()) {
- composeReference("author", element.getAuthor());
- }
- if (element.hasStep()) {
- for (Protocol.ProtocolStepComponent e : element.getStep())
- composeProtocolProtocolStepComponent("step", e);
- }
- }
-
- protected void composeProtocolProtocolStepComponent(String name, Protocol.ProtocolStepComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProtocolProtocolStepComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProtocolProtocolStepComponentElements(Protocol.ProtocolStepComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasDuration()) {
- composeDuration("duration", element.getDuration());
- }
- if (element.hasPrecondition()) {
- composeProtocolProtocolStepPreconditionComponent("precondition", element.getPrecondition());
- }
- if (element.hasExit()) {
- composeProtocolProtocolStepPreconditionComponent("exit", element.getExit());
- }
- if (element.hasFirstActivityElement()) {
- composeUri("firstActivity", element.getFirstActivityElement());
- }
- if (element.hasActivity()) {
- for (Protocol.ProtocolStepActivityComponent e : element.getActivity())
- composeProtocolProtocolStepActivityComponent("activity", e);
- }
- if (element.hasNext()) {
- for (Protocol.ProtocolStepNextComponent e : element.getNext())
- composeProtocolProtocolStepNextComponent("next", e);
- }
- }
-
- protected void composeProtocolProtocolStepPreconditionComponent(String name, Protocol.ProtocolStepPreconditionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProtocolProtocolStepPreconditionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProtocolProtocolStepPreconditionComponentElements(Protocol.ProtocolStepPreconditionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasCondition()) {
- composeProtocolProtocolStepPreconditionConditionComponent("condition", element.getCondition());
- }
- if (element.hasIntersection()) {
- for (Protocol.ProtocolStepPreconditionComponent e : element.getIntersection())
- composeProtocolProtocolStepPreconditionComponent("intersection", e);
- }
- if (element.hasUnion()) {
- for (Protocol.ProtocolStepPreconditionComponent e : element.getUnion())
- composeProtocolProtocolStepPreconditionComponent("union", e);
- }
- if (element.hasExclude()) {
- for (Protocol.ProtocolStepPreconditionComponent e : element.getExclude())
- composeProtocolProtocolStepPreconditionComponent("exclude", e);
- }
- }
-
- protected void composeProtocolProtocolStepPreconditionConditionComponent(String name, Protocol.ProtocolStepPreconditionConditionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProtocolProtocolStepPreconditionConditionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProtocolProtocolStepPreconditionConditionComponentElements(Protocol.ProtocolStepPreconditionConditionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeProtocolProtocolStepActivityComponent(String name, Protocol.ProtocolStepActivityComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProtocolProtocolStepActivityComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProtocolProtocolStepActivityComponentElements(Protocol.ProtocolStepActivityComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasAlternative()) {
- for (UriType e : element.getAlternative())
- composeUri("alternative", e);
- }
- if (element.hasComponent()) {
- for (Protocol.ProtocolStepActivityComponentComponent e : element.getComponent())
- composeProtocolProtocolStepActivityComponentComponent("component", e);
- }
- if (element.hasFollowing()) {
- for (UriType e : element.getFollowing())
- composeUri("following", e);
- }
- if (element.hasWait()) {
- composeDuration("wait", element.getWait());
- }
- if (element.hasDetail()) {
- composeProtocolProtocolStepActivityDetailComponent("detail", element.getDetail());
- }
- }
-
- protected void composeProtocolProtocolStepActivityComponentComponent(String name, Protocol.ProtocolStepActivityComponentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProtocolProtocolStepActivityComponentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProtocolProtocolStepActivityComponentComponentElements(Protocol.ProtocolStepActivityComponentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSequenceElement()) {
- composeInteger("sequence", element.getSequenceElement());
- }
- if (element.hasActivityElement()) {
- composeUri("activity", element.getActivityElement());
- }
- }
-
- protected void composeProtocolProtocolStepActivityDetailComponent(String name, Protocol.ProtocolStepActivityDetailComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProtocolProtocolStepActivityDetailComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProtocolProtocolStepActivityDetailComponentElements(Protocol.ProtocolStepActivityDetailComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCategoryElement())
- composeEnumeration("category", element.getCategoryElement(), new Protocol.ActivityDefinitionCategoryEnumFactory());
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasTiming()) {
- composeType("timing", element.getTiming());
- } if (element.hasLocation()) {
- composeReference("location", element.getLocation());
- }
- if (element.hasPerformer()) {
- for (Reference e : element.getPerformer())
- composeReference("performer", e);
- }
- if (element.hasProduct()) {
- composeType("product", element.getProduct());
- } if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- }
-
- protected void composeProtocolProtocolStepNextComponent(String name, Protocol.ProtocolStepNextComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProtocolProtocolStepNextComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProtocolProtocolStepNextComponentElements(Protocol.ProtocolStepNextComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasReferenceElement()) {
- composeUri("reference", element.getReferenceElement());
- }
- if (element.hasCondition()) {
- composeProtocolProtocolStepPreconditionComponent("condition", element.getCondition());
- }
- }
-
- protected void composeProvenance(String name, Provenance element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProvenanceElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProvenanceElements(Provenance element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasTarget()) {
- for (Reference e : element.getTarget())
- composeReference("target", e);
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasRecordedElement()) {
- composeInstant("recorded", element.getRecordedElement());
- }
- if (element.hasReason()) {
- for (Coding e : element.getReason())
- composeCoding("reason", e);
- }
- if (element.hasActivity()) {
- composeCoding("activity", element.getActivity());
- }
- if (element.hasLocation()) {
- composeReference("location", element.getLocation());
- }
- if (element.hasPolicy()) {
- for (UriType e : element.getPolicy())
- composeUri("policy", e);
- }
- if (element.hasAgent()) {
- for (Provenance.ProvenanceAgentComponent e : element.getAgent())
- composeProvenanceProvenanceAgentComponent("agent", e);
- }
- if (element.hasEntity()) {
- for (Provenance.ProvenanceEntityComponent e : element.getEntity())
- composeProvenanceProvenanceEntityComponent("entity", e);
- }
- if (element.hasSignature()) {
- for (Signature e : element.getSignature())
- composeSignature("signature", e);
- }
- }
-
- protected void composeProvenanceProvenanceAgentComponent(String name, Provenance.ProvenanceAgentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProvenanceProvenanceAgentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProvenanceProvenanceAgentComponentElements(Provenance.ProvenanceAgentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRole()) {
- composeCoding("role", element.getRole());
- }
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasUserId()) {
- composeIdentifier("userId", element.getUserId());
- }
- if (element.hasRelatedAgent()) {
- for (Provenance.ProvenanceAgentRelatedAgentComponent e : element.getRelatedAgent())
- composeProvenanceProvenanceAgentRelatedAgentComponent("relatedAgent", e);
- }
- }
-
- protected void composeProvenanceProvenanceAgentRelatedAgentComponent(String name, Provenance.ProvenanceAgentRelatedAgentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProvenanceProvenanceAgentRelatedAgentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProvenanceProvenanceAgentRelatedAgentComponentElements(Provenance.ProvenanceAgentRelatedAgentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasTargetElement()) {
- composeUri("target", element.getTargetElement());
- }
- }
-
- protected void composeProvenanceProvenanceEntityComponent(String name, Provenance.ProvenanceEntityComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeProvenanceProvenanceEntityComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeProvenanceProvenanceEntityComponentElements(Provenance.ProvenanceEntityComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRoleElement())
- composeEnumeration("role", element.getRoleElement(), new Provenance.ProvenanceEntityRoleEnumFactory());
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasReferenceElement()) {
- composeUri("reference", element.getReferenceElement());
- }
- if (element.hasDisplayElement()) {
- composeString("display", element.getDisplayElement());
- }
- if (element.hasAgent()) {
- composeProvenanceProvenanceAgentComponent("agent", element.getAgent());
- }
- }
-
- protected void composeQuestionnaire(String name, Questionnaire element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeQuestionnaireElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeQuestionnaireElements(Questionnaire element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Questionnaire.QuestionnaireStatusEnumFactory());
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasTitleElement()) {
- composeString("title", element.getTitleElement());
- }
- if (element.hasConcept()) {
- for (Coding e : element.getConcept())
- composeCoding("concept", e);
- }
- if (element.hasSubjectType()) {
- for (CodeType e : element.getSubjectType())
- composeCode("subjectType", e);
- }
- if (element.hasItem()) {
- for (Questionnaire.QuestionnaireItemComponent e : element.getItem())
- composeQuestionnaireQuestionnaireItemComponent("item", e);
- }
- }
-
- protected void composeQuestionnaireQuestionnaireItemComponent(String name, Questionnaire.QuestionnaireItemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeQuestionnaireQuestionnaireItemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeQuestionnaireQuestionnaireItemComponentElements(Questionnaire.QuestionnaireItemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLinkIdElement()) {
- composeString("linkId", element.getLinkIdElement());
- }
- if (element.hasConcept()) {
- for (Coding e : element.getConcept())
- composeCoding("concept", e);
- }
- if (element.hasPrefixElement()) {
- composeString("prefix", element.getPrefixElement());
- }
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Questionnaire.QuestionnaireItemTypeEnumFactory());
- if (element.hasEnableWhen()) {
- for (Questionnaire.QuestionnaireItemEnableWhenComponent e : element.getEnableWhen())
- composeQuestionnaireQuestionnaireItemEnableWhenComponent("enableWhen", e);
- }
- if (element.hasRequiredElement()) {
- composeBoolean("required", element.getRequiredElement());
- }
- if (element.hasRepeatsElement()) {
- composeBoolean("repeats", element.getRepeatsElement());
- }
- if (element.hasReadOnlyElement()) {
- composeBoolean("readOnly", element.getReadOnlyElement());
- }
- if (element.hasMaxLengthElement()) {
- composeInteger("maxLength", element.getMaxLengthElement());
- }
- if (element.hasOptions()) {
- composeReference("options", element.getOptions());
- }
- if (element.hasOption()) {
- for (Questionnaire.QuestionnaireItemOptionComponent e : element.getOption())
- composeQuestionnaireQuestionnaireItemOptionComponent("option", e);
- }
- if (element.hasInitial()) {
- composeType("initial", element.getInitial());
- } if (element.hasItem()) {
- for (Questionnaire.QuestionnaireItemComponent e : element.getItem())
- composeQuestionnaireQuestionnaireItemComponent("item", e);
- }
- }
-
- protected void composeQuestionnaireQuestionnaireItemEnableWhenComponent(String name, Questionnaire.QuestionnaireItemEnableWhenComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeQuestionnaireQuestionnaireItemEnableWhenComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeQuestionnaireQuestionnaireItemEnableWhenComponentElements(Questionnaire.QuestionnaireItemEnableWhenComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasQuestionElement()) {
- composeString("question", element.getQuestionElement());
- }
- if (element.hasHasAnswerElement()) {
- composeBoolean("hasAnswer", element.getHasAnswerElement());
- }
- if (element.hasAnswer()) {
- composeType("answer", element.getAnswer());
- } }
-
- protected void composeQuestionnaireQuestionnaireItemOptionComponent(String name, Questionnaire.QuestionnaireItemOptionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeQuestionnaireQuestionnaireItemOptionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeQuestionnaireQuestionnaireItemOptionComponentElements(Questionnaire.QuestionnaireItemOptionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeQuestionnaireResponse(String name, QuestionnaireResponse element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeQuestionnaireResponseElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeQuestionnaireResponseElements(QuestionnaireResponse element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasQuestionnaire()) {
- composeReference("questionnaire", element.getQuestionnaire());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new QuestionnaireResponse.QuestionnaireResponseStatusEnumFactory());
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasAuthor()) {
- composeReference("author", element.getAuthor());
- }
- if (element.hasAuthoredElement()) {
- composeDateTime("authored", element.getAuthoredElement());
- }
- if (element.hasSource()) {
- composeReference("source", element.getSource());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasItem()) {
- for (QuestionnaireResponse.QuestionnaireResponseItemComponent e : element.getItem())
- composeQuestionnaireResponseQuestionnaireResponseItemComponent("item", e);
- }
- }
-
- protected void composeQuestionnaireResponseQuestionnaireResponseItemComponent(String name, QuestionnaireResponse.QuestionnaireResponseItemComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeQuestionnaireResponseQuestionnaireResponseItemComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeQuestionnaireResponseQuestionnaireResponseItemComponentElements(QuestionnaireResponse.QuestionnaireResponseItemComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLinkIdElement()) {
- composeString("linkId", element.getLinkIdElement());
- }
- if (element.hasTextElement()) {
- composeString("text", element.getTextElement());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasAnswer()) {
- for (QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent e : element.getAnswer())
- composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponent("answer", e);
- }
- if (element.hasItem()) {
- for (QuestionnaireResponse.QuestionnaireResponseItemComponent e : element.getItem())
- composeQuestionnaireResponseQuestionnaireResponseItemComponent("item", e);
- }
- }
-
- protected void composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponent(String name, QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeQuestionnaireResponseQuestionnaireResponseItemAnswerComponentElements(QuestionnaireResponse.QuestionnaireResponseItemAnswerComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } if (element.hasItem()) {
- for (QuestionnaireResponse.QuestionnaireResponseItemComponent e : element.getItem())
- composeQuestionnaireResponseQuestionnaireResponseItemComponent("item", e);
- }
- }
-
- protected void composeReferralRequest(String name, ReferralRequest element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeReferralRequestElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeReferralRequestElements(ReferralRequest element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasBasedOn()) {
- for (Reference e : element.getBasedOn())
- composeReference("basedOn", e);
- }
- if (element.hasParent()) {
- composeIdentifier("parent", element.getParent());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new ReferralRequest.ReferralStatusEnumFactory());
- if (element.hasCategoryElement())
- composeEnumeration("category", element.getCategoryElement(), new ReferralRequest.ReferralCategoryEnumFactory());
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasPriority()) {
- composeCodeableConcept("priority", element.getPriority());
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasContext()) {
- composeReference("context", element.getContext());
- }
- if (element.hasFulfillmentTime()) {
- composePeriod("fulfillmentTime", element.getFulfillmentTime());
- }
- if (element.hasAuthoredElement()) {
- composeDateTime("authored", element.getAuthoredElement());
- }
- if (element.hasRequester()) {
- composeReference("requester", element.getRequester());
- }
- if (element.hasSpecialty()) {
- composeCodeableConcept("specialty", element.getSpecialty());
- }
- if (element.hasRecipient()) {
- for (Reference e : element.getRecipient())
- composeReference("recipient", e);
- }
- if (element.hasReason()) {
- composeCodeableConcept("reason", element.getReason());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasServiceRequested()) {
- for (CodeableConcept e : element.getServiceRequested())
- composeCodeableConcept("serviceRequested", e);
- }
- if (element.hasSupportingInformation()) {
- for (Reference e : element.getSupportingInformation())
- composeReference("supportingInformation", e);
- }
- }
-
- protected void composeRelatedPerson(String name, RelatedPerson element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeRelatedPersonElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeRelatedPersonElements(RelatedPerson element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasRelationship()) {
- composeCodeableConcept("relationship", element.getRelationship());
- }
- if (element.hasName()) {
- composeHumanName("name", element.getName());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- if (element.hasGenderElement())
- composeEnumeration("gender", element.getGenderElement(), new Enumerations.AdministrativeGenderEnumFactory());
- if (element.hasBirthDateElement()) {
- composeDate("birthDate", element.getBirthDateElement());
- }
- if (element.hasAddress()) {
- for (Address e : element.getAddress())
- composeAddress("address", e);
- }
- if (element.hasPhoto()) {
- for (Attachment e : element.getPhoto())
- composeAttachment("photo", e);
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- }
-
- protected void composeRiskAssessment(String name, RiskAssessment element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeRiskAssessmentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeRiskAssessmentElements(RiskAssessment element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasCondition()) {
- composeReference("condition", element.getCondition());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasPerformer()) {
- composeReference("performer", element.getPerformer());
- }
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasMethod()) {
- composeCodeableConcept("method", element.getMethod());
- }
- if (element.hasBasis()) {
- for (Reference e : element.getBasis())
- composeReference("basis", e);
- }
- if (element.hasPrediction()) {
- for (RiskAssessment.RiskAssessmentPredictionComponent e : element.getPrediction())
- composeRiskAssessmentRiskAssessmentPredictionComponent("prediction", e);
- }
- if (element.hasMitigationElement()) {
- composeString("mitigation", element.getMitigationElement());
- }
- }
-
- protected void composeRiskAssessmentRiskAssessmentPredictionComponent(String name, RiskAssessment.RiskAssessmentPredictionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeRiskAssessmentRiskAssessmentPredictionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeRiskAssessmentRiskAssessmentPredictionComponentElements(RiskAssessment.RiskAssessmentPredictionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasOutcome()) {
- composeCodeableConcept("outcome", element.getOutcome());
- }
- if (element.hasProbability()) {
- composeType("probability", element.getProbability());
- } if (element.hasRelativeRiskElement()) {
- composeDecimal("relativeRisk", element.getRelativeRiskElement());
- }
- if (element.hasWhen()) {
- composeType("when", element.getWhen());
- } if (element.hasRationaleElement()) {
- composeString("rationale", element.getRationaleElement());
- }
- }
-
- protected void composeSchedule(String name, Schedule element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeScheduleElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeScheduleElements(Schedule element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasServiceCategory()) {
- composeCodeableConcept("serviceCategory", element.getServiceCategory());
- }
- if (element.hasServiceType()) {
- for (CodeableConcept e : element.getServiceType())
- composeCodeableConcept("serviceType", e);
- }
- if (element.hasSpecialty()) {
- for (CodeableConcept e : element.getSpecialty())
- composeCodeableConcept("specialty", e);
- }
- if (element.hasActor()) {
- composeReference("actor", element.getActor());
- }
- if (element.hasPlanningHorizon()) {
- composePeriod("planningHorizon", element.getPlanningHorizon());
- }
- if (element.hasCommentElement()) {
- composeString("comment", element.getCommentElement());
- }
- }
-
- protected void composeSearchParameter(String name, SearchParameter element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSearchParameterElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSearchParameterElements(SearchParameter element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (SearchParameter.SearchParameterContactComponent e : element.getContact())
- composeSearchParameterSearchParameterContactComponent("contact", e);
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasRequirementsElement()) {
- composeString("requirements", element.getRequirementsElement());
- }
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasBaseElement()) {
- composeCode("base", element.getBaseElement());
- }
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Enumerations.SearchParamTypeEnumFactory());
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasExpressionElement()) {
- composeString("expression", element.getExpressionElement());
- }
- if (element.hasXpathElement()) {
- composeString("xpath", element.getXpathElement());
- }
- if (element.hasXpathUsageElement())
- composeEnumeration("xpathUsage", element.getXpathUsageElement(), new SearchParameter.XPathUsageTypeEnumFactory());
- if (element.hasTarget()) {
- for (CodeType e : element.getTarget())
- composeCode("target", e);
- }
- }
-
- protected void composeSearchParameterSearchParameterContactComponent(String name, SearchParameter.SearchParameterContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSearchParameterSearchParameterContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSearchParameterSearchParameterContactComponentElements(SearchParameter.SearchParameterContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeSequence(String name, Sequence element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSequenceElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSequenceElements(Sequence element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Sequence.SequenceTypeEnumFactory());
- if (element.hasCoordinateSystemElement()) {
- composeInteger("coordinateSystem", element.getCoordinateSystemElement());
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasSpecimen()) {
- composeReference("specimen", element.getSpecimen());
- }
- if (element.hasDevice()) {
- composeReference("device", element.getDevice());
- }
- if (element.hasQuantity()) {
- composeQuantity("quantity", element.getQuantity());
- }
- if (element.hasReferenceSeq()) {
- composeSequenceSequenceReferenceSeqComponent("referenceSeq", element.getReferenceSeq());
- }
- if (element.hasVariant()) {
- for (Sequence.SequenceVariantComponent e : element.getVariant())
- composeSequenceSequenceVariantComponent("variant", e);
- }
- if (element.hasObservedSeqElement()) {
- composeString("observedSeq", element.getObservedSeqElement());
- }
- if (element.hasQuality()) {
- for (Sequence.SequenceQualityComponent e : element.getQuality())
- composeSequenceSequenceQualityComponent("quality", e);
- }
- if (element.hasReadCoverageElement()) {
- composeInteger("readCoverage", element.getReadCoverageElement());
- }
- if (element.hasRepository()) {
- for (Sequence.SequenceRepositoryComponent e : element.getRepository())
- composeSequenceSequenceRepositoryComponent("repository", e);
- }
- if (element.hasPointer()) {
- for (Reference e : element.getPointer())
- composeReference("pointer", e);
- }
- if (element.hasStructureVariant()) {
- composeSequenceSequenceStructureVariantComponent("structureVariant", element.getStructureVariant());
- }
- }
-
- protected void composeSequenceSequenceReferenceSeqComponent(String name, Sequence.SequenceReferenceSeqComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSequenceSequenceReferenceSeqComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSequenceSequenceReferenceSeqComponentElements(Sequence.SequenceReferenceSeqComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasChromosome()) {
- composeCodeableConcept("chromosome", element.getChromosome());
- }
- if (element.hasGenomeBuildElement()) {
- composeString("genomeBuild", element.getGenomeBuildElement());
- }
- if (element.hasReferenceSeqId()) {
- composeCodeableConcept("referenceSeqId", element.getReferenceSeqId());
- }
- if (element.hasReferenceSeqPointer()) {
- composeReference("referenceSeqPointer", element.getReferenceSeqPointer());
- }
- if (element.hasReferenceSeqStringElement()) {
- composeString("referenceSeqString", element.getReferenceSeqStringElement());
- }
- if (element.hasStrandElement()) {
- composeInteger("strand", element.getStrandElement());
- }
- if (element.hasWindowStartElement()) {
- composeInteger("windowStart", element.getWindowStartElement());
- }
- if (element.hasWindowEndElement()) {
- composeInteger("windowEnd", element.getWindowEndElement());
- }
- }
-
- protected void composeSequenceSequenceVariantComponent(String name, Sequence.SequenceVariantComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSequenceSequenceVariantComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSequenceSequenceVariantComponentElements(Sequence.SequenceVariantComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStartElement()) {
- composeInteger("start", element.getStartElement());
- }
- if (element.hasEndElement()) {
- composeInteger("end", element.getEndElement());
- }
- if (element.hasObservedAlleleElement()) {
- composeString("observedAllele", element.getObservedAlleleElement());
- }
- if (element.hasReferenceAlleleElement()) {
- composeString("referenceAllele", element.getReferenceAlleleElement());
- }
- if (element.hasCigarElement()) {
- composeString("cigar", element.getCigarElement());
- }
- }
-
- protected void composeSequenceSequenceQualityComponent(String name, Sequence.SequenceQualityComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSequenceSequenceQualityComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSequenceSequenceQualityComponentElements(Sequence.SequenceQualityComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStartElement()) {
- composeInteger("start", element.getStartElement());
- }
- if (element.hasEndElement()) {
- composeInteger("end", element.getEndElement());
- }
- if (element.hasScore()) {
- composeQuantity("score", element.getScore());
- }
- if (element.hasMethodElement()) {
- composeString("method", element.getMethodElement());
- }
- if (element.hasTruePositivesElement()) {
- composeDecimal("truePositives", element.getTruePositivesElement());
- }
- if (element.hasFalsePositivesElement()) {
- composeDecimal("falsePositives", element.getFalsePositivesElement());
- }
- if (element.hasFalseNegativesElement()) {
- composeDecimal("falseNegatives", element.getFalseNegativesElement());
- }
- if (element.hasPrecisionElement()) {
- composeDecimal("precision", element.getPrecisionElement());
- }
- if (element.hasRecallElement()) {
- composeDecimal("recall", element.getRecallElement());
- }
- if (element.hasFMeasureElement()) {
- composeDecimal("fMeasure", element.getFMeasureElement());
- }
- }
-
- protected void composeSequenceSequenceRepositoryComponent(String name, Sequence.SequenceRepositoryComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSequenceSequenceRepositoryComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSequenceSequenceRepositoryComponentElements(Sequence.SequenceRepositoryComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasVariantIdElement()) {
- composeString("variantId", element.getVariantIdElement());
- }
- if (element.hasReadIdElement()) {
- composeString("readId", element.getReadIdElement());
- }
- }
-
- protected void composeSequenceSequenceStructureVariantComponent(String name, Sequence.SequenceStructureVariantComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSequenceSequenceStructureVariantComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSequenceSequenceStructureVariantComponentElements(Sequence.SequenceStructureVariantComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasPrecisionOfBoundariesElement()) {
- composeString("precisionOfBoundaries", element.getPrecisionOfBoundariesElement());
- }
- if (element.hasReportedaCGHRatioElement()) {
- composeDecimal("reportedaCGHRatio", element.getReportedaCGHRatioElement());
- }
- if (element.hasLengthElement()) {
- composeInteger("length", element.getLengthElement());
- }
- if (element.hasOuter()) {
- composeSequenceSequenceStructureVariantOuterComponent("outer", element.getOuter());
- }
- if (element.hasInner()) {
- composeSequenceSequenceStructureVariantInnerComponent("inner", element.getInner());
- }
- }
-
- protected void composeSequenceSequenceStructureVariantOuterComponent(String name, Sequence.SequenceStructureVariantOuterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSequenceSequenceStructureVariantOuterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSequenceSequenceStructureVariantOuterComponentElements(Sequence.SequenceStructureVariantOuterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStartElement()) {
- composeInteger("start", element.getStartElement());
- }
- if (element.hasEndElement()) {
- composeInteger("end", element.getEndElement());
- }
- }
-
- protected void composeSequenceSequenceStructureVariantInnerComponent(String name, Sequence.SequenceStructureVariantInnerComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSequenceSequenceStructureVariantInnerComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSequenceSequenceStructureVariantInnerComponentElements(Sequence.SequenceStructureVariantInnerComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasStartElement()) {
- composeInteger("start", element.getStartElement());
- }
- if (element.hasEndElement()) {
- composeInteger("end", element.getEndElement());
- }
- }
-
- protected void composeSlot(String name, Slot element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSlotElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSlotElements(Slot element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasServiceCategory()) {
- composeCodeableConcept("serviceCategory", element.getServiceCategory());
- }
- if (element.hasServiceType()) {
- for (CodeableConcept e : element.getServiceType())
- composeCodeableConcept("serviceType", e);
- }
- if (element.hasSpecialty()) {
- for (CodeableConcept e : element.getSpecialty())
- composeCodeableConcept("specialty", e);
- }
- if (element.hasAppointmentType()) {
- composeCodeableConcept("appointmentType", element.getAppointmentType());
- }
- if (element.hasSchedule()) {
- composeReference("schedule", element.getSchedule());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Slot.SlotStatusEnumFactory());
- if (element.hasStartElement()) {
- composeInstant("start", element.getStartElement());
- }
- if (element.hasEndElement()) {
- composeInstant("end", element.getEndElement());
- }
- if (element.hasOverbookedElement()) {
- composeBoolean("overbooked", element.getOverbookedElement());
- }
- if (element.hasCommentElement()) {
- composeString("comment", element.getCommentElement());
- }
- }
-
- protected void composeSpecimen(String name, Specimen element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSpecimenElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSpecimenElements(Specimen element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasAccessionIdentifier()) {
- composeIdentifier("accessionIdentifier", element.getAccessionIdentifier());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Specimen.SpecimenStatusEnumFactory());
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasSubject()) {
- composeReference("subject", element.getSubject());
- }
- if (element.hasReceivedTimeElement()) {
- composeDateTime("receivedTime", element.getReceivedTimeElement());
- }
- if (element.hasParent()) {
- for (Reference e : element.getParent())
- composeReference("parent", e);
- }
- if (element.hasRequest()) {
- for (Reference e : element.getRequest())
- composeReference("request", e);
- }
- if (element.hasCollection()) {
- composeSpecimenSpecimenCollectionComponent("collection", element.getCollection());
- }
- if (element.hasTreatment()) {
- for (Specimen.SpecimenTreatmentComponent e : element.getTreatment())
- composeSpecimenSpecimenTreatmentComponent("treatment", e);
- }
- if (element.hasContainer()) {
- for (Specimen.SpecimenContainerComponent e : element.getContainer())
- composeSpecimenSpecimenContainerComponent("container", e);
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- }
-
- protected void composeSpecimenSpecimenCollectionComponent(String name, Specimen.SpecimenCollectionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSpecimenSpecimenCollectionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSpecimenSpecimenCollectionComponentElements(Specimen.SpecimenCollectionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCollector()) {
- composeReference("collector", element.getCollector());
- }
- if (element.hasCollected()) {
- composeType("collected", element.getCollected());
- } if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasMethod()) {
- composeCodeableConcept("method", element.getMethod());
- }
- if (element.hasBodySite()) {
- composeCodeableConcept("bodySite", element.getBodySite());
- }
- }
-
- protected void composeSpecimenSpecimenTreatmentComponent(String name, Specimen.SpecimenTreatmentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSpecimenSpecimenTreatmentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSpecimenSpecimenTreatmentComponentElements(Specimen.SpecimenTreatmentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasProcedure()) {
- composeCodeableConcept("procedure", element.getProcedure());
- }
- if (element.hasAdditive()) {
- for (Reference e : element.getAdditive())
- composeReference("additive", e);
- }
- if (element.hasTime()) {
- composeType("time", element.getTime());
- } }
-
- protected void composeSpecimenSpecimenContainerComponent(String name, Specimen.SpecimenContainerComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSpecimenSpecimenContainerComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSpecimenSpecimenContainerComponentElements(Specimen.SpecimenContainerComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasCapacity()) {
- composeSimpleQuantity("capacity", element.getCapacity());
- }
- if (element.hasSpecimenQuantity()) {
- composeSimpleQuantity("specimenQuantity", element.getSpecimenQuantity());
- }
- if (element.hasAdditive()) {
- composeType("additive", element.getAdditive());
- } }
-
- protected void composeStructureDefinition(String name, StructureDefinition element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureDefinitionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureDefinitionElements(StructureDefinition element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDisplayElement()) {
- composeString("display", element.getDisplayElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (StructureDefinition.StructureDefinitionContactComponent e : element.getContact())
- composeStructureDefinitionStructureDefinitionContactComponent("contact", e);
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasRequirementsElement()) {
- composeString("requirements", element.getRequirementsElement());
- }
- if (element.hasCopyrightElement()) {
- composeString("copyright", element.getCopyrightElement());
- }
- if (element.hasCode()) {
- for (Coding e : element.getCode())
- composeCoding("code", e);
- }
- if (element.hasFhirVersionElement()) {
- composeId("fhirVersion", element.getFhirVersionElement());
- }
- if (element.hasMapping()) {
- for (StructureDefinition.StructureDefinitionMappingComponent e : element.getMapping())
- composeStructureDefinitionStructureDefinitionMappingComponent("mapping", e);
- }
- if (element.hasKindElement())
- composeEnumeration("kind", element.getKindElement(), new StructureDefinition.StructureDefinitionKindEnumFactory());
- if (element.hasAbstractElement()) {
- composeBoolean("abstract", element.getAbstractElement());
- }
- if (element.hasContextTypeElement())
- composeEnumeration("contextType", element.getContextTypeElement(), new StructureDefinition.ExtensionContextEnumFactory());
- if (element.hasContext()) {
- for (StringType e : element.getContext())
- composeString("context", e);
- }
- if (element.hasBaseTypeElement()) {
- composeCode("baseType", element.getBaseTypeElement());
- }
- if (element.hasBaseDefinitionElement()) {
- composeUri("baseDefinition", element.getBaseDefinitionElement());
- }
- if (element.hasDerivationElement())
- composeEnumeration("derivation", element.getDerivationElement(), new StructureDefinition.TypeDerivationRuleEnumFactory());
- if (element.hasSnapshot()) {
- composeStructureDefinitionStructureDefinitionSnapshotComponent("snapshot", element.getSnapshot());
- }
- if (element.hasDifferential()) {
- composeStructureDefinitionStructureDefinitionDifferentialComponent("differential", element.getDifferential());
- }
- }
-
- protected void composeStructureDefinitionStructureDefinitionContactComponent(String name, StructureDefinition.StructureDefinitionContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureDefinitionStructureDefinitionContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureDefinitionStructureDefinitionContactComponentElements(StructureDefinition.StructureDefinitionContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeStructureDefinitionStructureDefinitionMappingComponent(String name, StructureDefinition.StructureDefinitionMappingComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureDefinitionStructureDefinitionMappingComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureDefinitionStructureDefinitionMappingComponentElements(StructureDefinition.StructureDefinitionMappingComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentityElement()) {
- composeId("identity", element.getIdentityElement());
- }
- if (element.hasUriElement()) {
- composeUri("uri", element.getUriElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasCommentsElement()) {
- composeString("comments", element.getCommentsElement());
- }
- }
-
- protected void composeStructureDefinitionStructureDefinitionSnapshotComponent(String name, StructureDefinition.StructureDefinitionSnapshotComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureDefinitionStructureDefinitionSnapshotComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureDefinitionStructureDefinitionSnapshotComponentElements(StructureDefinition.StructureDefinitionSnapshotComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasElement()) {
- for (ElementDefinition e : element.getElement())
- composeElementDefinition("element", e);
- }
- }
-
- protected void composeStructureDefinitionStructureDefinitionDifferentialComponent(String name, StructureDefinition.StructureDefinitionDifferentialComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureDefinitionStructureDefinitionDifferentialComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureDefinitionStructureDefinitionDifferentialComponentElements(StructureDefinition.StructureDefinitionDifferentialComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasElement()) {
- for (ElementDefinition e : element.getElement())
- composeElementDefinition("element", e);
- }
- }
-
- protected void composeStructureMap(String name, StructureMap element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureMapElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureMapElements(StructureMap element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (StructureMap.StructureMapContactComponent e : element.getContact())
- composeStructureMapStructureMapContactComponent("contact", e);
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasRequirementsElement()) {
- composeString("requirements", element.getRequirementsElement());
- }
- if (element.hasCopyrightElement()) {
- composeString("copyright", element.getCopyrightElement());
- }
- if (element.hasStructure()) {
- for (StructureMap.StructureMapStructureComponent e : element.getStructure())
- composeStructureMapStructureMapStructureComponent("structure", e);
- }
- if (element.hasImport()) {
- for (UriType e : element.getImport())
- composeUri("import", e);
- }
- if (element.hasGroup()) {
- for (StructureMap.StructureMapGroupComponent e : element.getGroup())
- composeStructureMapStructureMapGroupComponent("group", e);
- }
- }
-
- protected void composeStructureMapStructureMapContactComponent(String name, StructureMap.StructureMapContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureMapStructureMapContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureMapStructureMapContactComponentElements(StructureMap.StructureMapContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeStructureMapStructureMapStructureComponent(String name, StructureMap.StructureMapStructureComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureMapStructureMapStructureComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureMapStructureMapStructureComponentElements(StructureMap.StructureMapStructureComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasModeElement())
- composeEnumeration("mode", element.getModeElement(), new StructureMap.StructureMapModelModeEnumFactory());
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- }
-
- protected void composeStructureMapStructureMapGroupComponent(String name, StructureMap.StructureMapGroupComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureMapStructureMapGroupComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureMapStructureMapGroupComponentElements(StructureMap.StructureMapGroupComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeId("name", element.getNameElement());
- }
- if (element.hasExtendsElement()) {
- composeId("extends", element.getExtendsElement());
- }
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- if (element.hasInput()) {
- for (StructureMap.StructureMapGroupInputComponent e : element.getInput())
- composeStructureMapStructureMapGroupInputComponent("input", e);
- }
- if (element.hasRule()) {
- for (StructureMap.StructureMapGroupRuleComponent e : element.getRule())
- composeStructureMapStructureMapGroupRuleComponent("rule", e);
- }
- }
-
- protected void composeStructureMapStructureMapGroupInputComponent(String name, StructureMap.StructureMapGroupInputComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureMapStructureMapGroupInputComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureMapStructureMapGroupInputComponentElements(StructureMap.StructureMapGroupInputComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeId("name", element.getNameElement());
- }
- if (element.hasTypeElement()) {
- composeString("type", element.getTypeElement());
- }
- if (element.hasModeElement())
- composeEnumeration("mode", element.getModeElement(), new StructureMap.StructureMapInputModeEnumFactory());
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- }
-
- protected void composeStructureMapStructureMapGroupRuleComponent(String name, StructureMap.StructureMapGroupRuleComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureMapStructureMapGroupRuleComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureMapStructureMapGroupRuleComponentElements(StructureMap.StructureMapGroupRuleComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeId("name", element.getNameElement());
- }
- if (element.hasSource()) {
- for (StructureMap.StructureMapGroupRuleSourceComponent e : element.getSource())
- composeStructureMapStructureMapGroupRuleSourceComponent("source", e);
- }
- if (element.hasTarget()) {
- for (StructureMap.StructureMapGroupRuleTargetComponent e : element.getTarget())
- composeStructureMapStructureMapGroupRuleTargetComponent("target", e);
- }
- if (element.hasRule()) {
- for (StructureMap.StructureMapGroupRuleComponent e : element.getRule())
- composeStructureMapStructureMapGroupRuleComponent("rule", e);
- }
- if (element.hasDependent()) {
- for (StructureMap.StructureMapGroupRuleDependentComponent e : element.getDependent())
- composeStructureMapStructureMapGroupRuleDependentComponent("dependent", e);
- }
- if (element.hasDocumentationElement()) {
- composeString("documentation", element.getDocumentationElement());
- }
- }
-
- protected void composeStructureMapStructureMapGroupRuleSourceComponent(String name, StructureMap.StructureMapGroupRuleSourceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureMapStructureMapGroupRuleSourceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureMapStructureMapGroupRuleSourceComponentElements(StructureMap.StructureMapGroupRuleSourceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRequiredElement()) {
- composeBoolean("required", element.getRequiredElement());
- }
- if (element.hasContextElement()) {
- composeId("context", element.getContextElement());
- }
- if (element.hasContextTypeElement())
- composeEnumeration("contextType", element.getContextTypeElement(), new StructureMap.StructureMapContextTypeEnumFactory());
- if (element.hasElementElement()) {
- composeString("element", element.getElementElement());
- }
- if (element.hasListModeElement())
- composeEnumeration("listMode", element.getListModeElement(), new StructureMap.StructureMapListModeEnumFactory());
- if (element.hasVariableElement()) {
- composeId("variable", element.getVariableElement());
- }
- if (element.hasConditionElement()) {
- composeString("condition", element.getConditionElement());
- }
- if (element.hasCheckElement()) {
- composeString("check", element.getCheckElement());
- }
- }
-
- protected void composeStructureMapStructureMapGroupRuleTargetComponent(String name, StructureMap.StructureMapGroupRuleTargetComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureMapStructureMapGroupRuleTargetComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureMapStructureMapGroupRuleTargetComponentElements(StructureMap.StructureMapGroupRuleTargetComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasContextElement()) {
- composeId("context", element.getContextElement());
- }
- if (element.hasContextTypeElement())
- composeEnumeration("contextType", element.getContextTypeElement(), new StructureMap.StructureMapContextTypeEnumFactory());
- if (element.hasElementElement()) {
- composeString("element", element.getElementElement());
- }
- if (element.hasVariableElement()) {
- composeId("variable", element.getVariableElement());
- }
- if (element.hasListMode())
- for (Enumeration e : element.getListMode())
- composeEnumeration("listMode", e, new StructureMap.StructureMapListModeEnumFactory());
- if (element.hasListRuleIdElement()) {
- composeId("listRuleId", element.getListRuleIdElement());
- }
- if (element.hasTransformElement())
- composeEnumeration("transform", element.getTransformElement(), new StructureMap.StructureMapTransformEnumFactory());
- if (element.hasParameter()) {
- for (StructureMap.StructureMapGroupRuleTargetParameterComponent e : element.getParameter())
- composeStructureMapStructureMapGroupRuleTargetParameterComponent("parameter", e);
- }
- }
-
- protected void composeStructureMapStructureMapGroupRuleTargetParameterComponent(String name, StructureMap.StructureMapGroupRuleTargetParameterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureMapStructureMapGroupRuleTargetParameterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureMapStructureMapGroupRuleTargetParameterComponentElements(StructureMap.StructureMapGroupRuleTargetParameterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeStructureMapStructureMapGroupRuleDependentComponent(String name, StructureMap.StructureMapGroupRuleDependentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeStructureMapStructureMapGroupRuleDependentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeStructureMapStructureMapGroupRuleDependentComponentElements(StructureMap.StructureMapGroupRuleDependentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeId("name", element.getNameElement());
- }
- if (element.hasVariable()) {
- for (StringType e : element.getVariable())
- composeString("variable", e);
- }
- }
-
- protected void composeSubscription(String name, Subscription element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSubscriptionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSubscriptionElements(Subscription element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasCriteriaElement()) {
- composeString("criteria", element.getCriteriaElement());
- }
- if (element.hasContact()) {
- for (ContactPoint e : element.getContact())
- composeContactPoint("contact", e);
- }
- if (element.hasReasonElement()) {
- composeString("reason", element.getReasonElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Subscription.SubscriptionStatusEnumFactory());
- if (element.hasErrorElement()) {
- composeString("error", element.getErrorElement());
- }
- if (element.hasChannel()) {
- composeSubscriptionSubscriptionChannelComponent("channel", element.getChannel());
- }
- if (element.hasEndElement()) {
- composeInstant("end", element.getEndElement());
- }
- if (element.hasTag()) {
- for (Coding e : element.getTag())
- composeCoding("tag", e);
- }
- }
-
- protected void composeSubscriptionSubscriptionChannelComponent(String name, Subscription.SubscriptionChannelComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSubscriptionSubscriptionChannelComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSubscriptionSubscriptionChannelComponentElements(Subscription.SubscriptionChannelComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasTypeElement())
- composeEnumeration("type", element.getTypeElement(), new Subscription.SubscriptionChannelTypeEnumFactory());
- if (element.hasEndpointElement()) {
- composeUri("endpoint", element.getEndpointElement());
- }
- if (element.hasPayloadElement()) {
- composeString("payload", element.getPayloadElement());
- }
- if (element.hasHeaderElement()) {
- composeString("header", element.getHeaderElement());
- }
- }
-
- protected void composeSubstance(String name, Substance element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSubstanceElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSubstanceElements(Substance element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasCategory()) {
- for (CodeableConcept e : element.getCategory())
- composeCodeableConcept("category", e);
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasInstance()) {
- for (Substance.SubstanceInstanceComponent e : element.getInstance())
- composeSubstanceSubstanceInstanceComponent("instance", e);
- }
- if (element.hasIngredient()) {
- for (Substance.SubstanceIngredientComponent e : element.getIngredient())
- composeSubstanceSubstanceIngredientComponent("ingredient", e);
- }
- }
-
- protected void composeSubstanceSubstanceInstanceComponent(String name, Substance.SubstanceInstanceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSubstanceSubstanceInstanceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSubstanceSubstanceInstanceComponentElements(Substance.SubstanceInstanceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasExpiryElement()) {
- composeDateTime("expiry", element.getExpiryElement());
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- }
-
- protected void composeSubstanceSubstanceIngredientComponent(String name, Substance.SubstanceIngredientComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSubstanceSubstanceIngredientComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSubstanceSubstanceIngredientComponentElements(Substance.SubstanceIngredientComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasQuantity()) {
- composeRatio("quantity", element.getQuantity());
- }
- if (element.hasSubstance()) {
- composeType("substance", element.getSubstance());
- } }
-
- protected void composeSupplyDelivery(String name, SupplyDelivery element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSupplyDeliveryElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSupplyDeliveryElements(SupplyDelivery element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new SupplyDelivery.SupplyDeliveryStatusEnumFactory());
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasType()) {
- composeCodeableConcept("type", element.getType());
- }
- if (element.hasQuantity()) {
- composeSimpleQuantity("quantity", element.getQuantity());
- }
- if (element.hasSuppliedItem()) {
- composeType("suppliedItem", element.getSuppliedItem());
- } if (element.hasSupplier()) {
- composeReference("supplier", element.getSupplier());
- }
- if (element.hasWhenPrepared()) {
- composePeriod("whenPrepared", element.getWhenPrepared());
- }
- if (element.hasTimeElement()) {
- composeDateTime("time", element.getTimeElement());
- }
- if (element.hasDestination()) {
- composeReference("destination", element.getDestination());
- }
- if (element.hasReceiver()) {
- for (Reference e : element.getReceiver())
- composeReference("receiver", e);
- }
- }
-
- protected void composeSupplyRequest(String name, SupplyRequest element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSupplyRequestElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSupplyRequestElements(SupplyRequest element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasSource()) {
- composeReference("source", element.getSource());
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new SupplyRequest.SupplyRequestStatusEnumFactory());
- if (element.hasKind()) {
- composeCodeableConcept("kind", element.getKind());
- }
- if (element.hasOrderedItem()) {
- composeType("orderedItem", element.getOrderedItem());
- } if (element.hasSupplier()) {
- for (Reference e : element.getSupplier())
- composeReference("supplier", e);
- }
- if (element.hasReason()) {
- composeType("reason", element.getReason());
- } if (element.hasWhen()) {
- composeSupplyRequestSupplyRequestWhenComponent("when", element.getWhen());
- }
- }
-
- protected void composeSupplyRequestSupplyRequestWhenComponent(String name, SupplyRequest.SupplyRequestWhenComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeSupplyRequestSupplyRequestWhenComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeSupplyRequestSupplyRequestWhenComponentElements(SupplyRequest.SupplyRequestWhenComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasSchedule()) {
- composeTiming("schedule", element.getSchedule());
- }
- }
-
- protected void composeTask(String name, Task element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTaskElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTaskElements(Task element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasBasedOn()) {
- for (Reference e : element.getBasedOn())
- composeReference("basedOn", e);
- }
- if (element.hasRequisition()) {
- composeIdentifier("requisition", element.getRequisition());
- }
- if (element.hasParent()) {
- for (Reference e : element.getParent())
- composeReference("parent", e);
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Task.TaskStatusEnumFactory());
- if (element.hasStatusReason()) {
- composeCodeableConcept("statusReason", element.getStatusReason());
- }
- if (element.hasBusinessStatus()) {
- composeCodeableConcept("businessStatus", element.getBusinessStatus());
- }
- if (element.hasStage()) {
- composeCodeableConcept("stage", element.getStage());
- }
- if (element.hasCode()) {
- composeCodeableConcept("code", element.getCode());
- }
- if (element.hasPriorityElement())
- composeEnumeration("priority", element.getPriorityElement(), new Task.TaskPriorityEnumFactory());
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasFocus()) {
- composeReference("focus", element.getFocus());
- }
- if (element.hasFor()) {
- composeReference("for", element.getFor());
- }
- if (element.hasContext()) {
- composeReference("context", element.getContext());
- }
- if (element.hasCreatedElement()) {
- composeDateTime("created", element.getCreatedElement());
- }
- if (element.hasLastModifiedElement()) {
- composeDateTime("lastModified", element.getLastModifiedElement());
- }
- if (element.hasRequester()) {
- composeReference("requester", element.getRequester());
- }
- if (element.hasOwner()) {
- composeReference("owner", element.getOwner());
- }
- if (element.hasPerformerType()) {
- for (CodeableConcept e : element.getPerformerType())
- composeCodeableConcept("performerType", e);
- }
- if (element.hasReason()) {
- composeCodeableConcept("reason", element.getReason());
- }
- if (element.hasNote()) {
- for (Annotation e : element.getNote())
- composeAnnotation("note", e);
- }
- if (element.hasFulfillment()) {
- composeTaskTaskFulfillmentComponent("fulfillment", element.getFulfillment());
- }
- if (element.hasDefinitionElement()) {
- composeUri("definition", element.getDefinitionElement());
- }
- if (element.hasInput()) {
- for (Task.ParameterComponent e : element.getInput())
- composeTaskParameterComponent("input", e);
- }
- if (element.hasOutput()) {
- for (Task.TaskOutputComponent e : element.getOutput())
- composeTaskTaskOutputComponent("output", e);
- }
- }
-
- protected void composeTaskTaskFulfillmentComponent(String name, Task.TaskFulfillmentComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTaskTaskFulfillmentComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTaskTaskFulfillmentComponentElements(Task.TaskFulfillmentComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRepetitionsElement()) {
- composePositiveInt("repetitions", element.getRepetitionsElement());
- }
- if (element.hasPeriod()) {
- composePeriod("period", element.getPeriod());
- }
- if (element.hasRecipients()) {
- for (Reference e : element.getRecipients())
- composeReference("recipients", e);
- }
- }
-
- protected void composeTaskParameterComponent(String name, Task.ParameterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTaskParameterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTaskParameterComponentElements(Task.ParameterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeTaskTaskOutputComponent(String name, Task.TaskOutputComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTaskTaskOutputComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTaskTaskOutputComponentElements(Task.TaskOutputComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeTestScript(String name, TestScript element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptElements(TestScript element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (TestScript.TestScriptContactComponent e : element.getContact())
- composeTestScriptTestScriptContactComponent("contact", e);
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasRequirementsElement()) {
- composeString("requirements", element.getRequirementsElement());
- }
- if (element.hasCopyrightElement()) {
- composeString("copyright", element.getCopyrightElement());
- }
- if (element.hasOrigin()) {
- for (TestScript.TestScriptOriginComponent e : element.getOrigin())
- composeTestScriptTestScriptOriginComponent("origin", e);
- }
- if (element.hasDestination()) {
- for (TestScript.TestScriptDestinationComponent e : element.getDestination())
- composeTestScriptTestScriptDestinationComponent("destination", e);
- }
- if (element.hasMetadata()) {
- composeTestScriptTestScriptMetadataComponent("metadata", element.getMetadata());
- }
- if (element.hasFixture()) {
- for (TestScript.TestScriptFixtureComponent e : element.getFixture())
- composeTestScriptTestScriptFixtureComponent("fixture", e);
- }
- if (element.hasProfile()) {
- for (Reference e : element.getProfile())
- composeReference("profile", e);
- }
- if (element.hasVariable()) {
- for (TestScript.TestScriptVariableComponent e : element.getVariable())
- composeTestScriptTestScriptVariableComponent("variable", e);
- }
- if (element.hasRule()) {
- for (TestScript.TestScriptRuleComponent e : element.getRule())
- composeTestScriptTestScriptRuleComponent("rule", e);
- }
- if (element.hasRuleset()) {
- for (TestScript.TestScriptRulesetComponent e : element.getRuleset())
- composeTestScriptTestScriptRulesetComponent("ruleset", e);
- }
- if (element.hasSetup()) {
- composeTestScriptTestScriptSetupComponent("setup", element.getSetup());
- }
- if (element.hasTest()) {
- for (TestScript.TestScriptTestComponent e : element.getTest())
- composeTestScriptTestScriptTestComponent("test", e);
- }
- if (element.hasTeardown()) {
- composeTestScriptTestScriptTeardownComponent("teardown", element.getTeardown());
- }
- }
-
- protected void composeTestScriptTestScriptContactComponent(String name, TestScript.TestScriptContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptContactComponentElements(TestScript.TestScriptContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeTestScriptTestScriptOriginComponent(String name, TestScript.TestScriptOriginComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptOriginComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptOriginComponentElements(TestScript.TestScriptOriginComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIndexElement()) {
- composeInteger("index", element.getIndexElement());
- }
- if (element.hasProfile()) {
- composeCoding("profile", element.getProfile());
- }
- }
-
- protected void composeTestScriptTestScriptDestinationComponent(String name, TestScript.TestScriptDestinationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptDestinationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptDestinationComponentElements(TestScript.TestScriptDestinationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIndexElement()) {
- composeInteger("index", element.getIndexElement());
- }
- if (element.hasProfile()) {
- composeCoding("profile", element.getProfile());
- }
- }
-
- protected void composeTestScriptTestScriptMetadataComponent(String name, TestScript.TestScriptMetadataComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptMetadataComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptMetadataComponentElements(TestScript.TestScriptMetadataComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLink()) {
- for (TestScript.TestScriptMetadataLinkComponent e : element.getLink())
- composeTestScriptTestScriptMetadataLinkComponent("link", e);
- }
- if (element.hasCapability()) {
- for (TestScript.TestScriptMetadataCapabilityComponent e : element.getCapability())
- composeTestScriptTestScriptMetadataCapabilityComponent("capability", e);
- }
- }
-
- protected void composeTestScriptTestScriptMetadataLinkComponent(String name, TestScript.TestScriptMetadataLinkComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptMetadataLinkComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptMetadataLinkComponentElements(TestScript.TestScriptMetadataLinkComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- }
-
- protected void composeTestScriptTestScriptMetadataCapabilityComponent(String name, TestScript.TestScriptMetadataCapabilityComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptMetadataCapabilityComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptMetadataCapabilityComponentElements(TestScript.TestScriptMetadataCapabilityComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRequiredElement()) {
- composeBoolean("required", element.getRequiredElement());
- }
- if (element.hasValidatedElement()) {
- composeBoolean("validated", element.getValidatedElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasOrigin()) {
- for (IntegerType e : element.getOrigin())
- composeInteger("origin", e);
- }
- if (element.hasDestinationElement()) {
- composeInteger("destination", element.getDestinationElement());
- }
- if (element.hasLink()) {
- for (UriType e : element.getLink())
- composeUri("link", e);
- }
- if (element.hasConformance()) {
- composeReference("conformance", element.getConformance());
- }
- }
-
- protected void composeTestScriptTestScriptFixtureComponent(String name, TestScript.TestScriptFixtureComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptFixtureComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptFixtureComponentElements(TestScript.TestScriptFixtureComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasAutocreateElement()) {
- composeBoolean("autocreate", element.getAutocreateElement());
- }
- if (element.hasAutodeleteElement()) {
- composeBoolean("autodelete", element.getAutodeleteElement());
- }
- if (element.hasResource()) {
- composeReference("resource", element.getResource());
- }
- }
-
- protected void composeTestScriptTestScriptVariableComponent(String name, TestScript.TestScriptVariableComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptVariableComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptVariableComponentElements(TestScript.TestScriptVariableComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDefaultValueElement()) {
- composeString("defaultValue", element.getDefaultValueElement());
- }
- if (element.hasHeaderFieldElement()) {
- composeString("headerField", element.getHeaderFieldElement());
- }
- if (element.hasPathElement()) {
- composeString("path", element.getPathElement());
- }
- if (element.hasSourceIdElement()) {
- composeId("sourceId", element.getSourceIdElement());
- }
- }
-
- protected void composeTestScriptTestScriptRuleComponent(String name, TestScript.TestScriptRuleComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptRuleComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptRuleComponentElements(TestScript.TestScriptRuleComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasResource()) {
- composeReference("resource", element.getResource());
- }
- if (element.hasParam()) {
- for (TestScript.TestScriptRuleParamComponent e : element.getParam())
- composeTestScriptTestScriptRuleParamComponent("param", e);
- }
- }
-
- protected void composeTestScriptTestScriptRuleParamComponent(String name, TestScript.TestScriptRuleParamComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptRuleParamComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptRuleParamComponentElements(TestScript.TestScriptRuleParamComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- }
-
- protected void composeTestScriptTestScriptRulesetComponent(String name, TestScript.TestScriptRulesetComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptRulesetComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptRulesetComponentElements(TestScript.TestScriptRulesetComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasResource()) {
- composeReference("resource", element.getResource());
- }
- if (element.hasRule()) {
- for (TestScript.TestScriptRulesetRuleComponent e : element.getRule())
- composeTestScriptTestScriptRulesetRuleComponent("rule", e);
- }
- }
-
- protected void composeTestScriptTestScriptRulesetRuleComponent(String name, TestScript.TestScriptRulesetRuleComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptRulesetRuleComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptRulesetRuleComponentElements(TestScript.TestScriptRulesetRuleComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRuleIdElement()) {
- composeId("ruleId", element.getRuleIdElement());
- }
- if (element.hasParam()) {
- for (TestScript.TestScriptRulesetRuleParamComponent e : element.getParam())
- composeTestScriptTestScriptRulesetRuleParamComponent("param", e);
- }
- }
-
- protected void composeTestScriptTestScriptRulesetRuleParamComponent(String name, TestScript.TestScriptRulesetRuleParamComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptRulesetRuleParamComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptRulesetRuleParamComponentElements(TestScript.TestScriptRulesetRuleParamComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- }
-
- protected void composeTestScriptTestScriptSetupComponent(String name, TestScript.TestScriptSetupComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptSetupComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptSetupComponentElements(TestScript.TestScriptSetupComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasMetadata()) {
- composeTestScriptTestScriptMetadataComponent("metadata", element.getMetadata());
- }
- if (element.hasAction()) {
- for (TestScript.SetupActionComponent e : element.getAction())
- composeTestScriptSetupActionComponent("action", e);
- }
- }
-
- protected void composeTestScriptSetupActionComponent(String name, TestScript.SetupActionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptSetupActionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptSetupActionComponentElements(TestScript.SetupActionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasOperation()) {
- composeTestScriptSetupActionOperationComponent("operation", element.getOperation());
- }
- if (element.hasAssert()) {
- composeTestScriptSetupActionAssertComponent("assert", element.getAssert());
- }
- }
-
- protected void composeTestScriptSetupActionOperationComponent(String name, TestScript.SetupActionOperationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptSetupActionOperationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptSetupActionOperationComponentElements(TestScript.SetupActionOperationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasType()) {
- composeCoding("type", element.getType());
- }
- if (element.hasResourceElement()) {
- composeCode("resource", element.getResourceElement());
- }
- if (element.hasLabelElement()) {
- composeString("label", element.getLabelElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasAcceptElement())
- composeEnumeration("accept", element.getAcceptElement(), new TestScript.ContentTypeEnumFactory());
- if (element.hasContentTypeElement())
- composeEnumeration("contentType", element.getContentTypeElement(), new TestScript.ContentTypeEnumFactory());
- if (element.hasDestinationElement()) {
- composeInteger("destination", element.getDestinationElement());
- }
- if (element.hasEncodeRequestUrlElement()) {
- composeBoolean("encodeRequestUrl", element.getEncodeRequestUrlElement());
- }
- if (element.hasOriginElement()) {
- composeInteger("origin", element.getOriginElement());
- }
- if (element.hasParamsElement()) {
- composeString("params", element.getParamsElement());
- }
- if (element.hasRequestHeader()) {
- for (TestScript.SetupActionOperationRequestHeaderComponent e : element.getRequestHeader())
- composeTestScriptSetupActionOperationRequestHeaderComponent("requestHeader", e);
- }
- if (element.hasResponseIdElement()) {
- composeId("responseId", element.getResponseIdElement());
- }
- if (element.hasSourceIdElement()) {
- composeId("sourceId", element.getSourceIdElement());
- }
- if (element.hasTargetIdElement()) {
- composeId("targetId", element.getTargetIdElement());
- }
- if (element.hasUrlElement()) {
- composeString("url", element.getUrlElement());
- }
- }
-
- protected void composeTestScriptSetupActionOperationRequestHeaderComponent(String name, TestScript.SetupActionOperationRequestHeaderComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptSetupActionOperationRequestHeaderComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptSetupActionOperationRequestHeaderComponentElements(TestScript.SetupActionOperationRequestHeaderComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasFieldElement()) {
- composeString("field", element.getFieldElement());
- }
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- }
-
- protected void composeTestScriptSetupActionAssertComponent(String name, TestScript.SetupActionAssertComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptSetupActionAssertComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptSetupActionAssertComponentElements(TestScript.SetupActionAssertComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLabelElement()) {
- composeString("label", element.getLabelElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasDirectionElement())
- composeEnumeration("direction", element.getDirectionElement(), new TestScript.AssertionDirectionTypeEnumFactory());
- if (element.hasCompareToSourceIdElement()) {
- composeString("compareToSourceId", element.getCompareToSourceIdElement());
- }
- if (element.hasCompareToSourcePathElement()) {
- composeString("compareToSourcePath", element.getCompareToSourcePathElement());
- }
- if (element.hasContentTypeElement())
- composeEnumeration("contentType", element.getContentTypeElement(), new TestScript.ContentTypeEnumFactory());
- if (element.hasHeaderFieldElement()) {
- composeString("headerField", element.getHeaderFieldElement());
- }
- if (element.hasMinimumIdElement()) {
- composeString("minimumId", element.getMinimumIdElement());
- }
- if (element.hasNavigationLinksElement()) {
- composeBoolean("navigationLinks", element.getNavigationLinksElement());
- }
- if (element.hasOperatorElement())
- composeEnumeration("operator", element.getOperatorElement(), new TestScript.AssertionOperatorTypeEnumFactory());
- if (element.hasPathElement()) {
- composeString("path", element.getPathElement());
- }
- if (element.hasResourceElement()) {
- composeCode("resource", element.getResourceElement());
- }
- if (element.hasResponseElement())
- composeEnumeration("response", element.getResponseElement(), new TestScript.AssertionResponseTypesEnumFactory());
- if (element.hasResponseCodeElement()) {
- composeString("responseCode", element.getResponseCodeElement());
- }
- if (element.hasRule()) {
- composeTestScriptSetupActionAssertRuleComponent("rule", element.getRule());
- }
- if (element.hasRuleset()) {
- composeTestScriptSetupActionAssertRulesetComponent("ruleset", element.getRuleset());
- }
- if (element.hasSourceIdElement()) {
- composeId("sourceId", element.getSourceIdElement());
- }
- if (element.hasValidateProfileIdElement()) {
- composeId("validateProfileId", element.getValidateProfileIdElement());
- }
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- if (element.hasWarningOnlyElement()) {
- composeBoolean("warningOnly", element.getWarningOnlyElement());
- }
- }
-
- protected void composeTestScriptSetupActionAssertRuleComponent(String name, TestScript.SetupActionAssertRuleComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptSetupActionAssertRuleComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptSetupActionAssertRuleComponentElements(TestScript.SetupActionAssertRuleComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRuleIdElement()) {
- composeId("ruleId", element.getRuleIdElement());
- }
- if (element.hasParam()) {
- for (TestScript.SetupActionAssertRuleParamComponent e : element.getParam())
- composeTestScriptSetupActionAssertRuleParamComponent("param", e);
- }
- }
-
- protected void composeTestScriptSetupActionAssertRuleParamComponent(String name, TestScript.SetupActionAssertRuleParamComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptSetupActionAssertRuleParamComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptSetupActionAssertRuleParamComponentElements(TestScript.SetupActionAssertRuleParamComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- }
-
- protected void composeTestScriptSetupActionAssertRulesetComponent(String name, TestScript.SetupActionAssertRulesetComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptSetupActionAssertRulesetComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptSetupActionAssertRulesetComponentElements(TestScript.SetupActionAssertRulesetComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRulesetIdElement()) {
- composeId("rulesetId", element.getRulesetIdElement());
- }
- if (element.hasRule()) {
- for (TestScript.SetupActionAssertRulesetRuleComponent e : element.getRule())
- composeTestScriptSetupActionAssertRulesetRuleComponent("rule", e);
- }
- }
-
- protected void composeTestScriptSetupActionAssertRulesetRuleComponent(String name, TestScript.SetupActionAssertRulesetRuleComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptSetupActionAssertRulesetRuleComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptSetupActionAssertRulesetRuleComponentElements(TestScript.SetupActionAssertRulesetRuleComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasRuleIdElement()) {
- composeId("ruleId", element.getRuleIdElement());
- }
- if (element.hasParam()) {
- for (TestScript.SetupActionAssertRulesetRuleParamComponent e : element.getParam())
- composeTestScriptSetupActionAssertRulesetRuleParamComponent("param", e);
- }
- }
-
- protected void composeTestScriptSetupActionAssertRulesetRuleParamComponent(String name, TestScript.SetupActionAssertRulesetRuleParamComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptSetupActionAssertRulesetRuleParamComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptSetupActionAssertRulesetRuleParamComponentElements(TestScript.SetupActionAssertRulesetRuleParamComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- }
-
- protected void composeTestScriptTestScriptTestComponent(String name, TestScript.TestScriptTestComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptTestComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptTestComponentElements(TestScript.TestScriptTestComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasMetadata()) {
- composeTestScriptTestScriptMetadataComponent("metadata", element.getMetadata());
- }
- if (element.hasAction()) {
- for (TestScript.TestActionComponent e : element.getAction())
- composeTestScriptTestActionComponent("action", e);
- }
- }
-
- protected void composeTestScriptTestActionComponent(String name, TestScript.TestActionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestActionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestActionComponentElements(TestScript.TestActionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasOperation()) {
- composeTestScriptSetupActionOperationComponent("operation", element.getOperation());
- }
- if (element.hasAssert()) {
- composeTestScriptSetupActionAssertComponent("assert", element.getAssert());
- }
- }
-
- protected void composeTestScriptTestScriptTeardownComponent(String name, TestScript.TestScriptTeardownComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTestScriptTeardownComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTestScriptTeardownComponentElements(TestScript.TestScriptTeardownComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasAction()) {
- for (TestScript.TeardownActionComponent e : element.getAction())
- composeTestScriptTeardownActionComponent("action", e);
- }
- }
-
- protected void composeTestScriptTeardownActionComponent(String name, TestScript.TeardownActionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeTestScriptTeardownActionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeTestScriptTeardownActionComponentElements(TestScript.TeardownActionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasOperation()) {
- composeTestScriptSetupActionOperationComponent("operation", element.getOperation());
- }
- }
-
- protected void composeValueSet(String name, ValueSet element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeValueSetElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeValueSetElements(ValueSet element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasUrlElement()) {
- composeUri("url", element.getUrlElement());
- }
- if (element.hasIdentifier()) {
- composeIdentifier("identifier", element.getIdentifier());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasStatusElement())
- composeEnumeration("status", element.getStatusElement(), new Enumerations.ConformanceResourceStatusEnumFactory());
- if (element.hasExperimentalElement()) {
- composeBoolean("experimental", element.getExperimentalElement());
- }
- if (element.hasPublisherElement()) {
- composeString("publisher", element.getPublisherElement());
- }
- if (element.hasContact()) {
- for (ValueSet.ValueSetContactComponent e : element.getContact())
- composeValueSetValueSetContactComponent("contact", e);
- }
- if (element.hasDateElement()) {
- composeDateTime("date", element.getDateElement());
- }
- if (element.hasLockedDateElement()) {
- composeDate("lockedDate", element.getLockedDateElement());
- }
- if (element.hasDescriptionElement()) {
- composeString("description", element.getDescriptionElement());
- }
- if (element.hasUseContext()) {
- for (CodeableConcept e : element.getUseContext())
- composeCodeableConcept("useContext", e);
- }
- if (element.hasImmutableElement()) {
- composeBoolean("immutable", element.getImmutableElement());
- }
- if (element.hasRequirementsElement()) {
- composeString("requirements", element.getRequirementsElement());
- }
- if (element.hasCopyrightElement()) {
- composeString("copyright", element.getCopyrightElement());
- }
- if (element.hasExtensibleElement()) {
- composeBoolean("extensible", element.getExtensibleElement());
- }
- if (element.hasCompose()) {
- composeValueSetValueSetComposeComponent("compose", element.getCompose());
- }
- if (element.hasExpansion()) {
- composeValueSetValueSetExpansionComponent("expansion", element.getExpansion());
- }
- }
-
- protected void composeValueSetValueSetContactComponent(String name, ValueSet.ValueSetContactComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeValueSetValueSetContactComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeValueSetValueSetContactComponentElements(ValueSet.ValueSetContactComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasTelecom()) {
- for (ContactPoint e : element.getTelecom())
- composeContactPoint("telecom", e);
- }
- }
-
- protected void composeValueSetValueSetComposeComponent(String name, ValueSet.ValueSetComposeComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeValueSetValueSetComposeComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeValueSetValueSetComposeComponentElements(ValueSet.ValueSetComposeComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasImport()) {
- for (UriType e : element.getImport())
- composeUri("import", e);
- }
- if (element.hasInclude()) {
- for (ValueSet.ConceptSetComponent e : element.getInclude())
- composeValueSetConceptSetComponent("include", e);
- }
- if (element.hasExclude()) {
- for (ValueSet.ConceptSetComponent e : element.getExclude())
- composeValueSetConceptSetComponent("exclude", e);
- }
- }
-
- protected void composeValueSetConceptSetComponent(String name, ValueSet.ConceptSetComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeValueSetConceptSetComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeValueSetConceptSetComponentElements(ValueSet.ConceptSetComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSystemElement()) {
- composeUri("system", element.getSystemElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasConcept()) {
- for (ValueSet.ConceptReferenceComponent e : element.getConcept())
- composeValueSetConceptReferenceComponent("concept", e);
- }
- if (element.hasFilter()) {
- for (ValueSet.ConceptSetFilterComponent e : element.getFilter())
- composeValueSetConceptSetFilterComponent("filter", e);
- }
- }
-
- protected void composeValueSetConceptReferenceComponent(String name, ValueSet.ConceptReferenceComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeValueSetConceptReferenceComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeValueSetConceptReferenceComponentElements(ValueSet.ConceptReferenceComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasDisplayElement()) {
- composeString("display", element.getDisplayElement());
- }
- if (element.hasDesignation()) {
- for (ValueSet.ConceptReferenceDesignationComponent e : element.getDesignation())
- composeValueSetConceptReferenceDesignationComponent("designation", e);
- }
- }
-
- protected void composeValueSetConceptReferenceDesignationComponent(String name, ValueSet.ConceptReferenceDesignationComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeValueSetConceptReferenceDesignationComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeValueSetConceptReferenceDesignationComponentElements(ValueSet.ConceptReferenceDesignationComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasLanguageElement()) {
- composeCode("language", element.getLanguageElement());
- }
- if (element.hasUse()) {
- composeCoding("use", element.getUse());
- }
- if (element.hasValueElement()) {
- composeString("value", element.getValueElement());
- }
- }
-
- protected void composeValueSetConceptSetFilterComponent(String name, ValueSet.ConceptSetFilterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeValueSetConceptSetFilterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeValueSetConceptSetFilterComponentElements(ValueSet.ConceptSetFilterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasPropertyElement()) {
- composeCode("property", element.getPropertyElement());
- }
- if (element.hasOpElement())
- composeEnumeration("op", element.getOpElement(), new ValueSet.FilterOperatorEnumFactory());
- if (element.hasValueElement()) {
- composeCode("value", element.getValueElement());
- }
- }
-
- protected void composeValueSetValueSetExpansionComponent(String name, ValueSet.ValueSetExpansionComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeValueSetValueSetExpansionComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeValueSetValueSetExpansionComponentElements(ValueSet.ValueSetExpansionComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasIdentifierElement()) {
- composeUri("identifier", element.getIdentifierElement());
- }
- if (element.hasTimestampElement()) {
- composeDateTime("timestamp", element.getTimestampElement());
- }
- if (element.hasTotalElement()) {
- composeInteger("total", element.getTotalElement());
- }
- if (element.hasOffsetElement()) {
- composeInteger("offset", element.getOffsetElement());
- }
- if (element.hasParameter()) {
- for (ValueSet.ValueSetExpansionParameterComponent e : element.getParameter())
- composeValueSetValueSetExpansionParameterComponent("parameter", e);
- }
- if (element.hasContains()) {
- for (ValueSet.ValueSetExpansionContainsComponent e : element.getContains())
- composeValueSetValueSetExpansionContainsComponent("contains", e);
- }
- }
-
- protected void composeValueSetValueSetExpansionParameterComponent(String name, ValueSet.ValueSetExpansionParameterComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeValueSetValueSetExpansionParameterComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeValueSetValueSetExpansionParameterComponentElements(ValueSet.ValueSetExpansionParameterComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasNameElement()) {
- composeString("name", element.getNameElement());
- }
- if (element.hasValue()) {
- composeType("value", element.getValue());
- } }
-
- protected void composeValueSetValueSetExpansionContainsComponent(String name, ValueSet.ValueSetExpansionContainsComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeValueSetValueSetExpansionContainsComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeValueSetValueSetExpansionContainsComponentElements(ValueSet.ValueSetExpansionContainsComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasSystemElement()) {
- composeUri("system", element.getSystemElement());
- }
- if (element.hasAbstractElement()) {
- composeBoolean("abstract", element.getAbstractElement());
- }
- if (element.hasVersionElement()) {
- composeString("version", element.getVersionElement());
- }
- if (element.hasCodeElement()) {
- composeCode("code", element.getCodeElement());
- }
- if (element.hasDisplayElement()) {
- composeString("display", element.getDisplayElement());
- }
- if (element.hasContains()) {
- for (ValueSet.ValueSetExpansionContainsComponent e : element.getContains())
- composeValueSetValueSetExpansionContainsComponent("contains", e);
- }
- }
-
- protected void composeVisionPrescription(String name, VisionPrescription element) throws IOException {
- if (element != null) {
- composeDomainResourceAttributes(element);
- xml.enter(FHIR_NS, name);
- composeVisionPrescriptionElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeVisionPrescriptionElements(VisionPrescription element) throws IOException {
- composeDomainResourceElements(element);
- if (element.hasIdentifier()) {
- for (Identifier e : element.getIdentifier())
- composeIdentifier("identifier", e);
- }
- if (element.hasDateWrittenElement()) {
- composeDateTime("dateWritten", element.getDateWrittenElement());
- }
- if (element.hasPatient()) {
- composeReference("patient", element.getPatient());
- }
- if (element.hasPrescriber()) {
- composeReference("prescriber", element.getPrescriber());
- }
- if (element.hasEncounter()) {
- composeReference("encounter", element.getEncounter());
- }
- if (element.hasReason()) {
- composeType("reason", element.getReason());
- } if (element.hasDispense()) {
- for (VisionPrescription.VisionPrescriptionDispenseComponent e : element.getDispense())
- composeVisionPrescriptionVisionPrescriptionDispenseComponent("dispense", e);
- }
- }
-
- protected void composeVisionPrescriptionVisionPrescriptionDispenseComponent(String name, VisionPrescription.VisionPrescriptionDispenseComponent element) throws IOException {
- if (element != null) {
- composeElementAttributes(element);
- xml.enter(FHIR_NS, name);
- composeVisionPrescriptionVisionPrescriptionDispenseComponentElements(element);
- composeElementClose(element);
- xml.exit(FHIR_NS, name);
- }
- }
-
- protected void composeVisionPrescriptionVisionPrescriptionDispenseComponentElements(VisionPrescription.VisionPrescriptionDispenseComponent element) throws IOException {
- composeBackboneElements(element);
- if (element.hasProduct()) {
- composeCoding("product", element.getProduct());
- }
- if (element.hasEyeElement())
- composeEnumeration("eye", element.getEyeElement(), new VisionPrescription.VisionEyesEnumFactory());
- if (element.hasSphereElement()) {
- composeDecimal("sphere", element.getSphereElement());
- }
- if (element.hasCylinderElement()) {
- composeDecimal("cylinder", element.getCylinderElement());
- }
- if (element.hasAxisElement()) {
- composeInteger("axis", element.getAxisElement());
- }
- if (element.hasPrismElement()) {
- composeDecimal("prism", element.getPrismElement());
- }
- if (element.hasBaseElement())
- composeEnumeration("base", element.getBaseElement(), new VisionPrescription.VisionBaseEnumFactory());
- if (element.hasAddElement()) {
- composeDecimal("add", element.getAddElement());
- }
- if (element.hasPowerElement()) {
- composeDecimal("power", element.getPowerElement());
- }
- if (element.hasBackCurveElement()) {
- composeDecimal("backCurve", element.getBackCurveElement());
- }
- if (element.hasDiameterElement()) {
- composeDecimal("diameter", element.getDiameterElement());
- }
- if (element.hasDuration()) {
- composeSimpleQuantity("duration", element.getDuration());
- }
- if (element.hasColorElement()) {
- composeString("color", element.getColorElement());
- }
- if (element.hasBrandElement()) {
- composeString("brand", element.getBrandElement());
- }
- if (element.hasNotesElement()) {
- composeString("notes", element.getNotesElement());
- }
- }
-
- @Override
- protected void composeResource(Resource resource) throws IOException {
- if (resource instanceof Parameters)
- composeParameters("Parameters", (Parameters)resource);
- else if (resource instanceof Account)
- composeAccount("Account", (Account)resource);
- else if (resource instanceof AllergyIntolerance)
- composeAllergyIntolerance("AllergyIntolerance", (AllergyIntolerance)resource);
- else if (resource instanceof Appointment)
- composeAppointment("Appointment", (Appointment)resource);
- else if (resource instanceof AppointmentResponse)
- composeAppointmentResponse("AppointmentResponse", (AppointmentResponse)resource);
- else if (resource instanceof AuditEvent)
- composeAuditEvent("AuditEvent", (AuditEvent)resource);
- else if (resource instanceof Basic)
- composeBasic("Basic", (Basic)resource);
- else if (resource instanceof Binary)
- composeBinary("Binary", (Binary)resource);
- else if (resource instanceof BodySite)
- composeBodySite("BodySite", (BodySite)resource);
- else if (resource instanceof Bundle)
- composeBundle("Bundle", (Bundle)resource);
- else if (resource instanceof CarePlan)
- composeCarePlan("CarePlan", (CarePlan)resource);
- else if (resource instanceof CareTeam)
- composeCareTeam("CareTeam", (CareTeam)resource);
- else if (resource instanceof Claim)
- composeClaim("Claim", (Claim)resource);
- else if (resource instanceof ClaimResponse)
- composeClaimResponse("ClaimResponse", (ClaimResponse)resource);
- else if (resource instanceof ClinicalImpression)
- composeClinicalImpression("ClinicalImpression", (ClinicalImpression)resource);
- else if (resource instanceof CodeSystem)
- composeCodeSystem("CodeSystem", (CodeSystem)resource);
- else if (resource instanceof Communication)
- composeCommunication("Communication", (Communication)resource);
- else if (resource instanceof CommunicationRequest)
- composeCommunicationRequest("CommunicationRequest", (CommunicationRequest)resource);
- else if (resource instanceof CompartmentDefinition)
- composeCompartmentDefinition("CompartmentDefinition", (CompartmentDefinition)resource);
- else if (resource instanceof Composition)
- composeComposition("Composition", (Composition)resource);
- else if (resource instanceof ConceptMap)
- composeConceptMap("ConceptMap", (ConceptMap)resource);
- else if (resource instanceof Condition)
- composeCondition("Condition", (Condition)resource);
- else if (resource instanceof Conformance)
- composeConformance("Conformance", (Conformance)resource);
- else if (resource instanceof Consent)
- composeConsent("Consent", (Consent)resource);
- else if (resource instanceof Contract)
- composeContract("Contract", (Contract)resource);
- else if (resource instanceof Coverage)
- composeCoverage("Coverage", (Coverage)resource);
- else if (resource instanceof DataElement)
- composeDataElement("DataElement", (DataElement)resource);
- else if (resource instanceof DecisionSupportRule)
- composeDecisionSupportRule("DecisionSupportRule", (DecisionSupportRule)resource);
- else if (resource instanceof DecisionSupportServiceModule)
- composeDecisionSupportServiceModule("DecisionSupportServiceModule", (DecisionSupportServiceModule)resource);
- else if (resource instanceof DetectedIssue)
- composeDetectedIssue("DetectedIssue", (DetectedIssue)resource);
- else if (resource instanceof Device)
- composeDevice("Device", (Device)resource);
- else if (resource instanceof DeviceComponent)
- composeDeviceComponent("DeviceComponent", (DeviceComponent)resource);
- else if (resource instanceof DeviceMetric)
- composeDeviceMetric("DeviceMetric", (DeviceMetric)resource);
- else if (resource instanceof DeviceUseRequest)
- composeDeviceUseRequest("DeviceUseRequest", (DeviceUseRequest)resource);
- else if (resource instanceof DeviceUseStatement)
- composeDeviceUseStatement("DeviceUseStatement", (DeviceUseStatement)resource);
- else if (resource instanceof DiagnosticOrder)
- composeDiagnosticOrder("DiagnosticOrder", (DiagnosticOrder)resource);
- else if (resource instanceof DiagnosticReport)
- composeDiagnosticReport("DiagnosticReport", (DiagnosticReport)resource);
- else if (resource instanceof DocumentManifest)
- composeDocumentManifest("DocumentManifest", (DocumentManifest)resource);
- else if (resource instanceof DocumentReference)
- composeDocumentReference("DocumentReference", (DocumentReference)resource);
- else if (resource instanceof EligibilityRequest)
- composeEligibilityRequest("EligibilityRequest", (EligibilityRequest)resource);
- else if (resource instanceof EligibilityResponse)
- composeEligibilityResponse("EligibilityResponse", (EligibilityResponse)resource);
- else if (resource instanceof Encounter)
- composeEncounter("Encounter", (Encounter)resource);
- else if (resource instanceof Endpoint)
- composeEndpoint("Endpoint", (Endpoint)resource);
- else if (resource instanceof EnrollmentRequest)
- composeEnrollmentRequest("EnrollmentRequest", (EnrollmentRequest)resource);
- else if (resource instanceof EnrollmentResponse)
- composeEnrollmentResponse("EnrollmentResponse", (EnrollmentResponse)resource);
- else if (resource instanceof EpisodeOfCare)
- composeEpisodeOfCare("EpisodeOfCare", (EpisodeOfCare)resource);
- else if (resource instanceof ExpansionProfile)
- composeExpansionProfile("ExpansionProfile", (ExpansionProfile)resource);
- else if (resource instanceof ExplanationOfBenefit)
- composeExplanationOfBenefit("ExplanationOfBenefit", (ExplanationOfBenefit)resource);
- else if (resource instanceof FamilyMemberHistory)
- composeFamilyMemberHistory("FamilyMemberHistory", (FamilyMemberHistory)resource);
- else if (resource instanceof Flag)
- composeFlag("Flag", (Flag)resource);
- else if (resource instanceof Goal)
- composeGoal("Goal", (Goal)resource);
- else if (resource instanceof Group)
- composeGroup("Group", (Group)resource);
- else if (resource instanceof GuidanceResponse)
- composeGuidanceResponse("GuidanceResponse", (GuidanceResponse)resource);
- else if (resource instanceof HealthcareService)
- composeHealthcareService("HealthcareService", (HealthcareService)resource);
- else if (resource instanceof ImagingStudy)
- composeImagingStudy("ImagingStudy", (ImagingStudy)resource);
- else if (resource instanceof Immunization)
- composeImmunization("Immunization", (Immunization)resource);
- else if (resource instanceof ImmunizationRecommendation)
- composeImmunizationRecommendation("ImmunizationRecommendation", (ImmunizationRecommendation)resource);
- else if (resource instanceof ImplementationGuide)
- composeImplementationGuide("ImplementationGuide", (ImplementationGuide)resource);
- else if (resource instanceof Library)
- composeLibrary("Library", (Library)resource);
- else if (resource instanceof Linkage)
- composeLinkage("Linkage", (Linkage)resource);
- else if (resource instanceof ListResource)
- composeListResource("List", (ListResource)resource);
- else if (resource instanceof Location)
- composeLocation("Location", (Location)resource);
- else if (resource instanceof Measure)
- composeMeasure("Measure", (Measure)resource);
- else if (resource instanceof MeasureReport)
- composeMeasureReport("MeasureReport", (MeasureReport)resource);
- else if (resource instanceof Media)
- composeMedia("Media", (Media)resource);
- else if (resource instanceof Medication)
- composeMedication("Medication", (Medication)resource);
- else if (resource instanceof MedicationAdministration)
- composeMedicationAdministration("MedicationAdministration", (MedicationAdministration)resource);
- else if (resource instanceof MedicationDispense)
- composeMedicationDispense("MedicationDispense", (MedicationDispense)resource);
- else if (resource instanceof MedicationOrder)
- composeMedicationOrder("MedicationOrder", (MedicationOrder)resource);
- else if (resource instanceof MedicationStatement)
- composeMedicationStatement("MedicationStatement", (MedicationStatement)resource);
- else if (resource instanceof MessageHeader)
- composeMessageHeader("MessageHeader", (MessageHeader)resource);
- else if (resource instanceof ModuleDefinition)
- composeModuleDefinition("ModuleDefinition", (ModuleDefinition)resource);
- else if (resource instanceof NamingSystem)
- composeNamingSystem("NamingSystem", (NamingSystem)resource);
- else if (resource instanceof NutritionOrder)
- composeNutritionOrder("NutritionOrder", (NutritionOrder)resource);
- else if (resource instanceof Observation)
- composeObservation("Observation", (Observation)resource);
- else if (resource instanceof OperationDefinition)
- composeOperationDefinition("OperationDefinition", (OperationDefinition)resource);
- else if (resource instanceof OperationOutcome)
- composeOperationOutcome("OperationOutcome", (OperationOutcome)resource);
- else if (resource instanceof Order)
- composeOrder("Order", (Order)resource);
- else if (resource instanceof OrderResponse)
- composeOrderResponse("OrderResponse", (OrderResponse)resource);
- else if (resource instanceof OrderSet)
- composeOrderSet("OrderSet", (OrderSet)resource);
- else if (resource instanceof Organization)
- composeOrganization("Organization", (Organization)resource);
- else if (resource instanceof Patient)
- composePatient("Patient", (Patient)resource);
- else if (resource instanceof PaymentNotice)
- composePaymentNotice("PaymentNotice", (PaymentNotice)resource);
- else if (resource instanceof PaymentReconciliation)
- composePaymentReconciliation("PaymentReconciliation", (PaymentReconciliation)resource);
- else if (resource instanceof Person)
- composePerson("Person", (Person)resource);
- else if (resource instanceof Practitioner)
- composePractitioner("Practitioner", (Practitioner)resource);
- else if (resource instanceof PractitionerRole)
- composePractitionerRole("PractitionerRole", (PractitionerRole)resource);
- else if (resource instanceof Procedure)
- composeProcedure("Procedure", (Procedure)resource);
- else if (resource instanceof ProcedureRequest)
- composeProcedureRequest("ProcedureRequest", (ProcedureRequest)resource);
- else if (resource instanceof ProcessRequest)
- composeProcessRequest("ProcessRequest", (ProcessRequest)resource);
- else if (resource instanceof ProcessResponse)
- composeProcessResponse("ProcessResponse", (ProcessResponse)resource);
- else if (resource instanceof Protocol)
- composeProtocol("Protocol", (Protocol)resource);
- else if (resource instanceof Provenance)
- composeProvenance("Provenance", (Provenance)resource);
- else if (resource instanceof Questionnaire)
- composeQuestionnaire("Questionnaire", (Questionnaire)resource);
- else if (resource instanceof QuestionnaireResponse)
- composeQuestionnaireResponse("QuestionnaireResponse", (QuestionnaireResponse)resource);
- else if (resource instanceof ReferralRequest)
- composeReferralRequest("ReferralRequest", (ReferralRequest)resource);
- else if (resource instanceof RelatedPerson)
- composeRelatedPerson("RelatedPerson", (RelatedPerson)resource);
- else if (resource instanceof RiskAssessment)
- composeRiskAssessment("RiskAssessment", (RiskAssessment)resource);
- else if (resource instanceof Schedule)
- composeSchedule("Schedule", (Schedule)resource);
- else if (resource instanceof SearchParameter)
- composeSearchParameter("SearchParameter", (SearchParameter)resource);
- else if (resource instanceof Sequence)
- composeSequence("Sequence", (Sequence)resource);
- else if (resource instanceof Slot)
- composeSlot("Slot", (Slot)resource);
- else if (resource instanceof Specimen)
- composeSpecimen("Specimen", (Specimen)resource);
- else if (resource instanceof StructureDefinition)
- composeStructureDefinition("StructureDefinition", (StructureDefinition)resource);
- else if (resource instanceof StructureMap)
- composeStructureMap("StructureMap", (StructureMap)resource);
- else if (resource instanceof Subscription)
- composeSubscription("Subscription", (Subscription)resource);
- else if (resource instanceof Substance)
- composeSubstance("Substance", (Substance)resource);
- else if (resource instanceof SupplyDelivery)
- composeSupplyDelivery("SupplyDelivery", (SupplyDelivery)resource);
- else if (resource instanceof SupplyRequest)
- composeSupplyRequest("SupplyRequest", (SupplyRequest)resource);
- else if (resource instanceof Task)
- composeTask("Task", (Task)resource);
- else if (resource instanceof TestScript)
- composeTestScript("TestScript", (TestScript)resource);
- else if (resource instanceof ValueSet)
- composeValueSet("ValueSet", (ValueSet)resource);
- else if (resource instanceof VisionPrescription)
- composeVisionPrescription("VisionPrescription", (VisionPrescription)resource);
- else if (resource instanceof Binary)
- composeBinary("Binary", (Binary)resource);
- else
- throw new Error("Unhandled resource type "+resource.getClass().getName());
- }
-
- protected void composeResource(String name, Resource resource) throws IOException {
- if (resource instanceof Parameters)
- composeParameters(name, (Parameters)resource);
- else if (resource instanceof Account)
- composeAccount(name, (Account)resource);
- else if (resource instanceof AllergyIntolerance)
- composeAllergyIntolerance(name, (AllergyIntolerance)resource);
- else if (resource instanceof Appointment)
- composeAppointment(name, (Appointment)resource);
- else if (resource instanceof AppointmentResponse)
- composeAppointmentResponse(name, (AppointmentResponse)resource);
- else if (resource instanceof AuditEvent)
- composeAuditEvent(name, (AuditEvent)resource);
- else if (resource instanceof Basic)
- composeBasic(name, (Basic)resource);
- else if (resource instanceof Binary)
- composeBinary(name, (Binary)resource);
- else if (resource instanceof BodySite)
- composeBodySite(name, (BodySite)resource);
- else if (resource instanceof Bundle)
- composeBundle(name, (Bundle)resource);
- else if (resource instanceof CarePlan)
- composeCarePlan(name, (CarePlan)resource);
- else if (resource instanceof CareTeam)
- composeCareTeam(name, (CareTeam)resource);
- else if (resource instanceof Claim)
- composeClaim(name, (Claim)resource);
- else if (resource instanceof ClaimResponse)
- composeClaimResponse(name, (ClaimResponse)resource);
- else if (resource instanceof ClinicalImpression)
- composeClinicalImpression(name, (ClinicalImpression)resource);
- else if (resource instanceof CodeSystem)
- composeCodeSystem(name, (CodeSystem)resource);
- else if (resource instanceof Communication)
- composeCommunication(name, (Communication)resource);
- else if (resource instanceof CommunicationRequest)
- composeCommunicationRequest(name, (CommunicationRequest)resource);
- else if (resource instanceof CompartmentDefinition)
- composeCompartmentDefinition(name, (CompartmentDefinition)resource);
- else if (resource instanceof Composition)
- composeComposition(name, (Composition)resource);
- else if (resource instanceof ConceptMap)
- composeConceptMap(name, (ConceptMap)resource);
- else if (resource instanceof Condition)
- composeCondition(name, (Condition)resource);
- else if (resource instanceof Conformance)
- composeConformance(name, (Conformance)resource);
- else if (resource instanceof Consent)
- composeConsent(name, (Consent)resource);
- else if (resource instanceof Contract)
- composeContract(name, (Contract)resource);
- else if (resource instanceof Coverage)
- composeCoverage(name, (Coverage)resource);
- else if (resource instanceof DataElement)
- composeDataElement(name, (DataElement)resource);
- else if (resource instanceof DecisionSupportRule)
- composeDecisionSupportRule(name, (DecisionSupportRule)resource);
- else if (resource instanceof DecisionSupportServiceModule)
- composeDecisionSupportServiceModule(name, (DecisionSupportServiceModule)resource);
- else if (resource instanceof DetectedIssue)
- composeDetectedIssue(name, (DetectedIssue)resource);
- else if (resource instanceof Device)
- composeDevice(name, (Device)resource);
- else if (resource instanceof DeviceComponent)
- composeDeviceComponent(name, (DeviceComponent)resource);
- else if (resource instanceof DeviceMetric)
- composeDeviceMetric(name, (DeviceMetric)resource);
- else if (resource instanceof DeviceUseRequest)
- composeDeviceUseRequest(name, (DeviceUseRequest)resource);
- else if (resource instanceof DeviceUseStatement)
- composeDeviceUseStatement(name, (DeviceUseStatement)resource);
- else if (resource instanceof DiagnosticOrder)
- composeDiagnosticOrder(name, (DiagnosticOrder)resource);
- else if (resource instanceof DiagnosticReport)
- composeDiagnosticReport(name, (DiagnosticReport)resource);
- else if (resource instanceof DocumentManifest)
- composeDocumentManifest(name, (DocumentManifest)resource);
- else if (resource instanceof DocumentReference)
- composeDocumentReference(name, (DocumentReference)resource);
- else if (resource instanceof EligibilityRequest)
- composeEligibilityRequest(name, (EligibilityRequest)resource);
- else if (resource instanceof EligibilityResponse)
- composeEligibilityResponse(name, (EligibilityResponse)resource);
- else if (resource instanceof Encounter)
- composeEncounter(name, (Encounter)resource);
- else if (resource instanceof Endpoint)
- composeEndpoint(name, (Endpoint)resource);
- else if (resource instanceof EnrollmentRequest)
- composeEnrollmentRequest(name, (EnrollmentRequest)resource);
- else if (resource instanceof EnrollmentResponse)
- composeEnrollmentResponse(name, (EnrollmentResponse)resource);
- else if (resource instanceof EpisodeOfCare)
- composeEpisodeOfCare(name, (EpisodeOfCare)resource);
- else if (resource instanceof ExpansionProfile)
- composeExpansionProfile(name, (ExpansionProfile)resource);
- else if (resource instanceof ExplanationOfBenefit)
- composeExplanationOfBenefit(name, (ExplanationOfBenefit)resource);
- else if (resource instanceof FamilyMemberHistory)
- composeFamilyMemberHistory(name, (FamilyMemberHistory)resource);
- else if (resource instanceof Flag)
- composeFlag(name, (Flag)resource);
- else if (resource instanceof Goal)
- composeGoal(name, (Goal)resource);
- else if (resource instanceof Group)
- composeGroup(name, (Group)resource);
- else if (resource instanceof GuidanceResponse)
- composeGuidanceResponse(name, (GuidanceResponse)resource);
- else if (resource instanceof HealthcareService)
- composeHealthcareService(name, (HealthcareService)resource);
- else if (resource instanceof ImagingStudy)
- composeImagingStudy(name, (ImagingStudy)resource);
- else if (resource instanceof Immunization)
- composeImmunization(name, (Immunization)resource);
- else if (resource instanceof ImmunizationRecommendation)
- composeImmunizationRecommendation(name, (ImmunizationRecommendation)resource);
- else if (resource instanceof ImplementationGuide)
- composeImplementationGuide(name, (ImplementationGuide)resource);
- else if (resource instanceof Library)
- composeLibrary(name, (Library)resource);
- else if (resource instanceof Linkage)
- composeLinkage(name, (Linkage)resource);
- else if (resource instanceof ListResource)
- composeListResource(name, (ListResource)resource);
- else if (resource instanceof Location)
- composeLocation(name, (Location)resource);
- else if (resource instanceof Measure)
- composeMeasure(name, (Measure)resource);
- else if (resource instanceof MeasureReport)
- composeMeasureReport(name, (MeasureReport)resource);
- else if (resource instanceof Media)
- composeMedia(name, (Media)resource);
- else if (resource instanceof Medication)
- composeMedication(name, (Medication)resource);
- else if (resource instanceof MedicationAdministration)
- composeMedicationAdministration(name, (MedicationAdministration)resource);
- else if (resource instanceof MedicationDispense)
- composeMedicationDispense(name, (MedicationDispense)resource);
- else if (resource instanceof MedicationOrder)
- composeMedicationOrder(name, (MedicationOrder)resource);
- else if (resource instanceof MedicationStatement)
- composeMedicationStatement(name, (MedicationStatement)resource);
- else if (resource instanceof MessageHeader)
- composeMessageHeader(name, (MessageHeader)resource);
- else if (resource instanceof ModuleDefinition)
- composeModuleDefinition(name, (ModuleDefinition)resource);
- else if (resource instanceof NamingSystem)
- composeNamingSystem(name, (NamingSystem)resource);
- else if (resource instanceof NutritionOrder)
- composeNutritionOrder(name, (NutritionOrder)resource);
- else if (resource instanceof Observation)
- composeObservation(name, (Observation)resource);
- else if (resource instanceof OperationDefinition)
- composeOperationDefinition(name, (OperationDefinition)resource);
- else if (resource instanceof OperationOutcome)
- composeOperationOutcome(name, (OperationOutcome)resource);
- else if (resource instanceof Order)
- composeOrder(name, (Order)resource);
- else if (resource instanceof OrderResponse)
- composeOrderResponse(name, (OrderResponse)resource);
- else if (resource instanceof OrderSet)
- composeOrderSet(name, (OrderSet)resource);
- else if (resource instanceof Organization)
- composeOrganization(name, (Organization)resource);
- else if (resource instanceof Patient)
- composePatient(name, (Patient)resource);
- else if (resource instanceof PaymentNotice)
- composePaymentNotice(name, (PaymentNotice)resource);
- else if (resource instanceof PaymentReconciliation)
- composePaymentReconciliation(name, (PaymentReconciliation)resource);
- else if (resource instanceof Person)
- composePerson(name, (Person)resource);
- else if (resource instanceof Practitioner)
- composePractitioner(name, (Practitioner)resource);
- else if (resource instanceof PractitionerRole)
- composePractitionerRole(name, (PractitionerRole)resource);
- else if (resource instanceof Procedure)
- composeProcedure(name, (Procedure)resource);
- else if (resource instanceof ProcedureRequest)
- composeProcedureRequest(name, (ProcedureRequest)resource);
- else if (resource instanceof ProcessRequest)
- composeProcessRequest(name, (ProcessRequest)resource);
- else if (resource instanceof ProcessResponse)
- composeProcessResponse(name, (ProcessResponse)resource);
- else if (resource instanceof Protocol)
- composeProtocol(name, (Protocol)resource);
- else if (resource instanceof Provenance)
- composeProvenance(name, (Provenance)resource);
- else if (resource instanceof Questionnaire)
- composeQuestionnaire(name, (Questionnaire)resource);
- else if (resource instanceof QuestionnaireResponse)
- composeQuestionnaireResponse(name, (QuestionnaireResponse)resource);
- else if (resource instanceof ReferralRequest)
- composeReferralRequest(name, (ReferralRequest)resource);
- else if (resource instanceof RelatedPerson)
- composeRelatedPerson(name, (RelatedPerson)resource);
- else if (resource instanceof RiskAssessment)
- composeRiskAssessment(name, (RiskAssessment)resource);
- else if (resource instanceof Schedule)
- composeSchedule(name, (Schedule)resource);
- else if (resource instanceof SearchParameter)
- composeSearchParameter(name, (SearchParameter)resource);
- else if (resource instanceof Sequence)
- composeSequence(name, (Sequence)resource);
- else if (resource instanceof Slot)
- composeSlot(name, (Slot)resource);
- else if (resource instanceof Specimen)
- composeSpecimen(name, (Specimen)resource);
- else if (resource instanceof StructureDefinition)
- composeStructureDefinition(name, (StructureDefinition)resource);
- else if (resource instanceof StructureMap)
- composeStructureMap(name, (StructureMap)resource);
- else if (resource instanceof Subscription)
- composeSubscription(name, (Subscription)resource);
- else if (resource instanceof Substance)
- composeSubstance(name, (Substance)resource);
- else if (resource instanceof SupplyDelivery)
- composeSupplyDelivery(name, (SupplyDelivery)resource);
- else if (resource instanceof SupplyRequest)
- composeSupplyRequest(name, (SupplyRequest)resource);
- else if (resource instanceof Task)
- composeTask(name, (Task)resource);
- else if (resource instanceof TestScript)
- composeTestScript(name, (TestScript)resource);
- else if (resource instanceof ValueSet)
- composeValueSet(name, (ValueSet)resource);
- else if (resource instanceof VisionPrescription)
- composeVisionPrescription(name, (VisionPrescription)resource);
- else if (resource instanceof Binary)
- composeBinary(name, (Binary)resource);
- else
- throw new Error("Unhandled resource type "+resource.getClass().getName());
- }
-
- protected void composeType(String prefix, Type type) throws IOException {
- if (type == null)
- ;
- else if (type instanceof SimpleQuantity)
- composeSimpleQuantity(prefix+"SimpleQuantity", (SimpleQuantity) type);
- else if (type instanceof Reference)
- composeReference(prefix+"Reference", (Reference) type);
- else if (type instanceof Quantity)
- composeQuantity(prefix+"Quantity", (Quantity) type);
- else if (type instanceof Period)
- composePeriod(prefix+"Period", (Period) type);
- else if (type instanceof Attachment)
- composeAttachment(prefix+"Attachment", (Attachment) type);
- else if (type instanceof Duration)
- composeDuration(prefix+"Duration", (Duration) type);
- else if (type instanceof Count)
- composeCount(prefix+"Count", (Count) type);
- else if (type instanceof Range)
- composeRange(prefix+"Range", (Range) type);
- else if (type instanceof Annotation)
- composeAnnotation(prefix+"Annotation", (Annotation) type);
- else if (type instanceof Money)
- composeMoney(prefix+"Money", (Money) type);
- else if (type instanceof Identifier)
- composeIdentifier(prefix+"Identifier", (Identifier) type);
- else if (type instanceof Coding)
- composeCoding(prefix+"Coding", (Coding) type);
- else if (type instanceof Signature)
- composeSignature(prefix+"Signature", (Signature) type);
- else if (type instanceof SampledData)
- composeSampledData(prefix+"SampledData", (SampledData) type);
- else if (type instanceof Ratio)
- composeRatio(prefix+"Ratio", (Ratio) type);
- else if (type instanceof Distance)
- composeDistance(prefix+"Distance", (Distance) type);
- else if (type instanceof Age)
- composeAge(prefix+"Age", (Age) type);
- else if (type instanceof CodeableConcept)
- composeCodeableConcept(prefix+"CodeableConcept", (CodeableConcept) type);
- else if (type instanceof HumanName)
- composeHumanName(prefix+"HumanName", (HumanName) type);
- else if (type instanceof ContactPoint)
- composeContactPoint(prefix+"ContactPoint", (ContactPoint) type);
- else if (type instanceof Meta)
- composeMeta(prefix+"Meta", (Meta) type);
- else if (type instanceof Address)
- composeAddress(prefix+"Address", (Address) type);
- else if (type instanceof TriggerDefinition)
- composeTriggerDefinition(prefix+"TriggerDefinition", (TriggerDefinition) type);
- else if (type instanceof ModuleMetadata)
- composeModuleMetadata(prefix+"ModuleMetadata", (ModuleMetadata) type);
- else if (type instanceof Timing)
- composeTiming(prefix+"Timing", (Timing) type);
- else if (type instanceof ElementDefinition)
- composeElementDefinition(prefix+"ElementDefinition", (ElementDefinition) type);
- else if (type instanceof DataRequirement)
- composeDataRequirement(prefix+"DataRequirement", (DataRequirement) type);
- else if (type instanceof ActionDefinition)
- composeActionDefinition(prefix+"ActionDefinition", (ActionDefinition) type);
- else if (type instanceof ParameterDefinition)
- composeParameterDefinition(prefix+"ParameterDefinition", (ParameterDefinition) type);
- else if (type instanceof CodeType)
- composeCode(prefix+"Code", (CodeType) type);
- else if (type instanceof OidType)
- composeOid(prefix+"Oid", (OidType) type);
- else if (type instanceof UuidType)
- composeUuid(prefix+"Uuid", (UuidType) type);
- else if (type instanceof UnsignedIntType)
- composeUnsignedInt(prefix+"UnsignedInt", (UnsignedIntType) type);
- else if (type instanceof MarkdownType)
- composeMarkdown(prefix+"Markdown", (MarkdownType) type);
- else if (type instanceof IdType)
- composeId(prefix+"Id", (IdType) type);
- else if (type instanceof PositiveIntType)
- composePositiveInt(prefix+"PositiveInt", (PositiveIntType) type);
- else if (type instanceof DateType)
- composeDate(prefix+"Date", (DateType) type);
- else if (type instanceof DateTimeType)
- composeDateTime(prefix+"DateTime", (DateTimeType) type);
- else if (type instanceof StringType)
- composeString(prefix+"String", (StringType) type);
- else if (type instanceof IntegerType)
- composeInteger(prefix+"Integer", (IntegerType) type);
- else if (type instanceof UriType)
- composeUri(prefix+"Uri", (UriType) type);
- else if (type instanceof InstantType)
- composeInstant(prefix+"Instant", (InstantType) type);
- else if (type instanceof BooleanType)
- composeBoolean(prefix+"Boolean", (BooleanType) type);
- else if (type instanceof Base64BinaryType)
- composeBase64Binary(prefix+"Base64Binary", (Base64BinaryType) type);
- else if (type instanceof TimeType)
- composeTime(prefix+"Time", (TimeType) type);
- else if (type instanceof DecimalType)
- composeDecimal(prefix+"Decimal", (DecimalType) type);
- else
- throw new Error("Unhandled type");
- }
-
-}
-
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Account.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Account.java
index 42b31bb31e8..aad41acf787 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Account.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Account.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -164,6 +164,7 @@ public class Account extends DomainResource {
*/
@Child(name = "status", type = {CodeType.class}, order=3, min=0, max=1, modifier=true, summary=true)
@Description(shortDefinition="active | inactive", formalDefinition="Indicates whether the account is presently used/useable or not." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/account-status")
protected Enumeration status;
/**
@@ -879,7 +880,7 @@ public class Account extends DomainResource {
* Path: Account.owner
*
*/
- @SearchParamDefinition(name="owner", path="Account.owner", description="Who is responsible?", type="reference", target={Organization.class} )
+ @SearchParamDefinition(name="owner", path="Account.owner", description="Who is responsible?", type="reference" )
public static final String SP_OWNER = "owner";
/**
* Fluent Client search parameter constant for owner
@@ -905,7 +906,7 @@ public class Account extends DomainResource {
* Path: Account.identifier
*
*/
- @SearchParamDefinition(name="identifier", path="Account.identifier", description="Account number", type="token", target={} )
+ @SearchParamDefinition(name="identifier", path="Account.identifier", description="Account number", type="token" )
public static final String SP_IDENTIFIER = "identifier";
/**
* Fluent Client search parameter constant for identifier
@@ -925,7 +926,7 @@ public class Account extends DomainResource {
* Path: Account.coveragePeriod
*
*/
- @SearchParamDefinition(name="period", path="Account.coveragePeriod", description="Transaction window", type="date", target={} )
+ @SearchParamDefinition(name="period", path="Account.coveragePeriod", description="Transaction window", type="date" )
public static final String SP_PERIOD = "period";
/**
* Fluent Client search parameter constant for period
@@ -945,7 +946,7 @@ public class Account extends DomainResource {
* Path: Account.balance
*
*/
- @SearchParamDefinition(name="balance", path="Account.balance", description="How much is in account?", type="quantity", target={} )
+ @SearchParamDefinition(name="balance", path="Account.balance", description="How much is in account?", type="quantity" )
public static final String SP_BALANCE = "balance";
/**
* Fluent Client search parameter constant for balance
@@ -965,7 +966,7 @@ public class Account extends DomainResource {
* Path: Account.subject
*
*/
- @SearchParamDefinition(name="subject", path="Account.subject", description="What is account tied to?", type="reference", target={Practitioner.class, Organization.class, Device.class, Patient.class, HealthcareService.class, Location.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner") } )
+ @SearchParamDefinition(name="subject", path="Account.subject", description="What is account tied to?", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner") } )
public static final String SP_SUBJECT = "subject";
/**
* Fluent Client search parameter constant for subject
@@ -991,7 +992,7 @@ public class Account extends DomainResource {
* Path: Account.subject
*
*/
- @SearchParamDefinition(name="patient", path="Account.subject", description="What is account tied to?", type="reference", target={Patient.class} )
+ @SearchParamDefinition(name="patient", path="Account.subject", description="What is account tied to?", type="reference" )
public static final String SP_PATIENT = "patient";
/**
* Fluent Client search parameter constant for patient
@@ -1017,7 +1018,7 @@ public class Account extends DomainResource {
* Path: Account.name
*
*/
- @SearchParamDefinition(name="name", path="Account.name", description="Human-readable label", type="string", target={} )
+ @SearchParamDefinition(name="name", path="Account.name", description="Human-readable label", type="string" )
public static final String SP_NAME = "name";
/**
* Fluent Client search parameter constant for name
@@ -1037,7 +1038,7 @@ public class Account extends DomainResource {
* Path: Account.type
*
*/
- @SearchParamDefinition(name="type", path="Account.type", description="E.g. patient, expense, depreciation", type="token", target={} )
+ @SearchParamDefinition(name="type", path="Account.type", description="E.g. patient, expense, depreciation", type="token" )
public static final String SP_TYPE = "type";
/**
* Fluent Client search parameter constant for type
@@ -1057,7 +1058,7 @@ public class Account extends DomainResource {
* Path: Account.status
*
*/
- @SearchParamDefinition(name="status", path="Account.status", description="active | inactive", type="token", target={} )
+ @SearchParamDefinition(name="status", path="Account.status", description="active | inactive", type="token" )
public static final String SP_STATUS = "status";
/**
* Fluent Client search parameter constant for status
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/ActionDefinition.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/ActionDefinition.java
index 6cba3be4bc0..499c9fd2a98 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/ActionDefinition.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/ActionDefinition.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sat, May 28, 2016 10:02-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -469,6 +469,7 @@ public class ActionDefinition extends Type implements ICompositeType {
*/
@Child(name = "relationship", type = {CodeType.class}, order=2, min=1, max=1, modifier=false, summary=true)
@Description(shortDefinition="before | after", formalDefinition="The relationship of this action to the related action." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-relationship-type")
protected Enumeration relationship;
/**
@@ -483,6 +484,7 @@ public class ActionDefinition extends Type implements ICompositeType {
*/
@Child(name = "anchor", type = {CodeType.class}, order=4, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="start | end", formalDefinition="An optional indicator for how the relationship is anchored to the related action. For example \"before the start\" or \"before the end\" of the related action." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-relationship-anchor")
protected Enumeration anchor;
private static final long serialVersionUID = 451097227L;
@@ -806,6 +808,7 @@ public class ActionDefinition extends Type implements ICompositeType {
*/
@Child(name = "type", type = {Coding.class}, order=1, min=1, max=1, modifier=false, summary=true)
@Description(shortDefinition="The type of behavior (grouping, precheck, selection, cardinality, etc)", formalDefinition="The type of the behavior to be described, such as grouping, visual, or selection behaviors." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-behavior-type")
protected Coding type;
/**
@@ -1277,6 +1280,7 @@ public class ActionDefinition extends Type implements ICompositeType {
*/
@Child(name = "participantType", type = {CodeType.class}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
@Description(shortDefinition="patient | practitioner | related-person", formalDefinition="The type of participant in the action." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-participant-type")
protected List> participantType;
/**
@@ -1284,6 +1288,7 @@ public class ActionDefinition extends Type implements ICompositeType {
*/
@Child(name = "type", type = {CodeType.class}, order=10, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="create | update | remove | fire-event", formalDefinition="The type of action to perform (create, update, remove)." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/action-type")
protected Enumeration type;
/**
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/ActivityDefinition.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/ActivityDefinition.java
new file mode 100644
index 00000000000..53a24e5eb39
--- /dev/null
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/ActivityDefinition.java
@@ -0,0 +1,2530 @@
+package org.hl7.fhir.dstu3.model;
+
+/*
+ Copyright (c) 2011+, HL7, Inc.
+ All rights reserved.
+
+ Redistribution and use in source and binary forms, with or without modification,
+ are permitted provided that the following conditions are met:
+
+ * Redistributions of source code must retain the above copyright notice, this
+ list of conditions and the following disclaimer.
+ * Redistributions in binary form must reproduce the above copyright notice,
+ this list of conditions and the following disclaimer in the documentation
+ and/or other materials provided with the distribution.
+ * Neither the name of HL7 nor the names of its contributors may be used to
+ endorse or promote products derived from this software without specific
+ prior written permission.
+
+ THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+ INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+ PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+ POSSIBILITY OF SUCH DAMAGE.
+
+*/
+
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
+
+import java.util.*;
+
+import org.hl7.fhir.utilities.Utilities;
+import ca.uhn.fhir.model.api.annotation.ResourceDef;
+import ca.uhn.fhir.model.api.annotation.SearchParamDefinition;
+import ca.uhn.fhir.model.api.annotation.Child;
+import ca.uhn.fhir.model.api.annotation.ChildOrder;
+import ca.uhn.fhir.model.api.annotation.Description;
+import ca.uhn.fhir.model.api.annotation.Block;
+import org.hl7.fhir.instance.model.api.*;
+import org.hl7.fhir.dstu3.exceptions.FHIRException;
+/**
+ * This resource allows for the definition of an order set as a sharable, consumable, and executable artifact in support of clinical decision support.
+ */
+@ResourceDef(name="ActivityDefinition", profile="http://hl7.org/fhir/Profile/ActivityDefinition")
+public class ActivityDefinition extends DomainResource {
+
+ public enum ActivityDefinitionCategory {
+ /**
+ * To communicate with a participant in some way
+ */
+ COMMUNICATION,
+ /**
+ * To consume food of a specified nature
+ */
+ DIET,
+ /**
+ * To consume/receive a drug, vaccine or other product
+ */
+ DRUG,
+ /**
+ * To meet with the patient (in-patient, out-patient, etc.)
+ */
+ ENCOUNTER,
+ /**
+ * To capture information about a patient (vitals, labs, diagnostic images, etc.)
+ */
+ OBSERVATION,
+ /**
+ * To modify the patient in some way (surgery, physiotherapy, education, counseling, etc.)
+ */
+ PROCEDURE,
+ /**
+ * To refer the patient to receive some service
+ */
+ REFERRAL,
+ /**
+ * To provide something to the patient (medication, medical supply, etc.)
+ */
+ SUPPLY,
+ /**
+ * Some other form of action
+ */
+ OTHER,
+ /**
+ * added to help the parsers with the generic types
+ */
+ NULL;
+ public static ActivityDefinitionCategory fromCode(String codeString) throws FHIRException {
+ if (codeString == null || "".equals(codeString))
+ return null;
+ if ("communication".equals(codeString))
+ return COMMUNICATION;
+ if ("diet".equals(codeString))
+ return DIET;
+ if ("drug".equals(codeString))
+ return DRUG;
+ if ("encounter".equals(codeString))
+ return ENCOUNTER;
+ if ("observation".equals(codeString))
+ return OBSERVATION;
+ if ("procedure".equals(codeString))
+ return PROCEDURE;
+ if ("referral".equals(codeString))
+ return REFERRAL;
+ if ("supply".equals(codeString))
+ return SUPPLY;
+ if ("other".equals(codeString))
+ return OTHER;
+ if (Configuration.isAcceptInvalidEnums())
+ return null;
+ else
+ throw new FHIRException("Unknown ActivityDefinitionCategory code '"+codeString+"'");
+ }
+ public String toCode() {
+ switch (this) {
+ case COMMUNICATION: return "communication";
+ case DIET: return "diet";
+ case DRUG: return "drug";
+ case ENCOUNTER: return "encounter";
+ case OBSERVATION: return "observation";
+ case PROCEDURE: return "procedure";
+ case REFERRAL: return "referral";
+ case SUPPLY: return "supply";
+ case OTHER: return "other";
+ default: return "?";
+ }
+ }
+ public String getSystem() {
+ switch (this) {
+ case COMMUNICATION: return "http://hl7.org/fhir/activity-definition-category";
+ case DIET: return "http://hl7.org/fhir/activity-definition-category";
+ case DRUG: return "http://hl7.org/fhir/activity-definition-category";
+ case ENCOUNTER: return "http://hl7.org/fhir/activity-definition-category";
+ case OBSERVATION: return "http://hl7.org/fhir/activity-definition-category";
+ case PROCEDURE: return "http://hl7.org/fhir/activity-definition-category";
+ case REFERRAL: return "http://hl7.org/fhir/activity-definition-category";
+ case SUPPLY: return "http://hl7.org/fhir/activity-definition-category";
+ case OTHER: return "http://hl7.org/fhir/activity-definition-category";
+ default: return "?";
+ }
+ }
+ public String getDefinition() {
+ switch (this) {
+ case COMMUNICATION: return "To communicate with a participant in some way";
+ case DIET: return "To consume food of a specified nature";
+ case DRUG: return "To consume/receive a drug, vaccine or other product";
+ case ENCOUNTER: return "To meet with the patient (in-patient, out-patient, etc.)";
+ case OBSERVATION: return "To capture information about a patient (vitals, labs, diagnostic images, etc.)";
+ case PROCEDURE: return "To modify the patient in some way (surgery, physiotherapy, education, counseling, etc.)";
+ case REFERRAL: return "To refer the patient to receive some service";
+ case SUPPLY: return "To provide something to the patient (medication, medical supply, etc.)";
+ case OTHER: return "Some other form of action";
+ default: return "?";
+ }
+ }
+ public String getDisplay() {
+ switch (this) {
+ case COMMUNICATION: return "Communication";
+ case DIET: return "Diet";
+ case DRUG: return "Drug";
+ case ENCOUNTER: return "Encounter";
+ case OBSERVATION: return "Observation";
+ case PROCEDURE: return "Procedure";
+ case REFERRAL: return "Referral";
+ case SUPPLY: return "Supply";
+ case OTHER: return "Other";
+ default: return "?";
+ }
+ }
+ }
+
+ public static class ActivityDefinitionCategoryEnumFactory implements EnumFactory {
+ public ActivityDefinitionCategory fromCode(String codeString) throws IllegalArgumentException {
+ if (codeString == null || "".equals(codeString))
+ if (codeString == null || "".equals(codeString))
+ return null;
+ if ("communication".equals(codeString))
+ return ActivityDefinitionCategory.COMMUNICATION;
+ if ("diet".equals(codeString))
+ return ActivityDefinitionCategory.DIET;
+ if ("drug".equals(codeString))
+ return ActivityDefinitionCategory.DRUG;
+ if ("encounter".equals(codeString))
+ return ActivityDefinitionCategory.ENCOUNTER;
+ if ("observation".equals(codeString))
+ return ActivityDefinitionCategory.OBSERVATION;
+ if ("procedure".equals(codeString))
+ return ActivityDefinitionCategory.PROCEDURE;
+ if ("referral".equals(codeString))
+ return ActivityDefinitionCategory.REFERRAL;
+ if ("supply".equals(codeString))
+ return ActivityDefinitionCategory.SUPPLY;
+ if ("other".equals(codeString))
+ return ActivityDefinitionCategory.OTHER;
+ throw new IllegalArgumentException("Unknown ActivityDefinitionCategory code '"+codeString+"'");
+ }
+ public Enumeration fromType(Base code) throws FHIRException {
+ if (code == null || code.isEmpty())
+ return null;
+ String codeString = ((PrimitiveType) code).asStringValue();
+ if (codeString == null || "".equals(codeString))
+ return null;
+ if ("communication".equals(codeString))
+ return new Enumeration(this, ActivityDefinitionCategory.COMMUNICATION);
+ if ("diet".equals(codeString))
+ return new Enumeration(this, ActivityDefinitionCategory.DIET);
+ if ("drug".equals(codeString))
+ return new Enumeration(this, ActivityDefinitionCategory.DRUG);
+ if ("encounter".equals(codeString))
+ return new Enumeration(this, ActivityDefinitionCategory.ENCOUNTER);
+ if ("observation".equals(codeString))
+ return new Enumeration(this, ActivityDefinitionCategory.OBSERVATION);
+ if ("procedure".equals(codeString))
+ return new Enumeration(this, ActivityDefinitionCategory.PROCEDURE);
+ if ("referral".equals(codeString))
+ return new Enumeration(this, ActivityDefinitionCategory.REFERRAL);
+ if ("supply".equals(codeString))
+ return new Enumeration(this, ActivityDefinitionCategory.SUPPLY);
+ if ("other".equals(codeString))
+ return new Enumeration(this, ActivityDefinitionCategory.OTHER);
+ throw new FHIRException("Unknown ActivityDefinitionCategory code '"+codeString+"'");
+ }
+ public String toCode(ActivityDefinitionCategory code) {
+ if (code == ActivityDefinitionCategory.COMMUNICATION)
+ return "communication";
+ if (code == ActivityDefinitionCategory.DIET)
+ return "diet";
+ if (code == ActivityDefinitionCategory.DRUG)
+ return "drug";
+ if (code == ActivityDefinitionCategory.ENCOUNTER)
+ return "encounter";
+ if (code == ActivityDefinitionCategory.OBSERVATION)
+ return "observation";
+ if (code == ActivityDefinitionCategory.PROCEDURE)
+ return "procedure";
+ if (code == ActivityDefinitionCategory.REFERRAL)
+ return "referral";
+ if (code == ActivityDefinitionCategory.SUPPLY)
+ return "supply";
+ if (code == ActivityDefinitionCategory.OTHER)
+ return "other";
+ return "?";
+ }
+ public String toSystem(ActivityDefinitionCategory code) {
+ return code.getSystem();
+ }
+ }
+
+ public enum ActivityParticipantType {
+ /**
+ * The participant is the patient under evaluation
+ */
+ PATIENT,
+ /**
+ * The participant is a practitioner involved in the patient's care
+ */
+ PRACTITIONER,
+ /**
+ * The participant is a person related to the patient
+ */
+ RELATEDPERSON,
+ /**
+ * added to help the parsers with the generic types
+ */
+ NULL;
+ public static ActivityParticipantType fromCode(String codeString) throws FHIRException {
+ if (codeString == null || "".equals(codeString))
+ return null;
+ if ("patient".equals(codeString))
+ return PATIENT;
+ if ("practitioner".equals(codeString))
+ return PRACTITIONER;
+ if ("related-person".equals(codeString))
+ return RELATEDPERSON;
+ if (Configuration.isAcceptInvalidEnums())
+ return null;
+ else
+ throw new FHIRException("Unknown ActivityParticipantType code '"+codeString+"'");
+ }
+ public String toCode() {
+ switch (this) {
+ case PATIENT: return "patient";
+ case PRACTITIONER: return "practitioner";
+ case RELATEDPERSON: return "related-person";
+ default: return "?";
+ }
+ }
+ public String getSystem() {
+ switch (this) {
+ case PATIENT: return "http://hl7.org/fhir/activity-participant-type";
+ case PRACTITIONER: return "http://hl7.org/fhir/activity-participant-type";
+ case RELATEDPERSON: return "http://hl7.org/fhir/activity-participant-type";
+ default: return "?";
+ }
+ }
+ public String getDefinition() {
+ switch (this) {
+ case PATIENT: return "The participant is the patient under evaluation";
+ case PRACTITIONER: return "The participant is a practitioner involved in the patient's care";
+ case RELATEDPERSON: return "The participant is a person related to the patient";
+ default: return "?";
+ }
+ }
+ public String getDisplay() {
+ switch (this) {
+ case PATIENT: return "Patient";
+ case PRACTITIONER: return "Practitioner";
+ case RELATEDPERSON: return "Related Person";
+ default: return "?";
+ }
+ }
+ }
+
+ public static class ActivityParticipantTypeEnumFactory implements EnumFactory {
+ public ActivityParticipantType fromCode(String codeString) throws IllegalArgumentException {
+ if (codeString == null || "".equals(codeString))
+ if (codeString == null || "".equals(codeString))
+ return null;
+ if ("patient".equals(codeString))
+ return ActivityParticipantType.PATIENT;
+ if ("practitioner".equals(codeString))
+ return ActivityParticipantType.PRACTITIONER;
+ if ("related-person".equals(codeString))
+ return ActivityParticipantType.RELATEDPERSON;
+ throw new IllegalArgumentException("Unknown ActivityParticipantType code '"+codeString+"'");
+ }
+ public Enumeration fromType(Base code) throws FHIRException {
+ if (code == null || code.isEmpty())
+ return null;
+ String codeString = ((PrimitiveType) code).asStringValue();
+ if (codeString == null || "".equals(codeString))
+ return null;
+ if ("patient".equals(codeString))
+ return new Enumeration(this, ActivityParticipantType.PATIENT);
+ if ("practitioner".equals(codeString))
+ return new Enumeration(this, ActivityParticipantType.PRACTITIONER);
+ if ("related-person".equals(codeString))
+ return new Enumeration(this, ActivityParticipantType.RELATEDPERSON);
+ throw new FHIRException("Unknown ActivityParticipantType code '"+codeString+"'");
+ }
+ public String toCode(ActivityParticipantType code) {
+ if (code == ActivityParticipantType.PATIENT)
+ return "patient";
+ if (code == ActivityParticipantType.PRACTITIONER)
+ return "practitioner";
+ if (code == ActivityParticipantType.RELATEDPERSON)
+ return "related-person";
+ return "?";
+ }
+ public String toSystem(ActivityParticipantType code) {
+ return code.getSystem();
+ }
+ }
+
+ /**
+ * An absolute URL that is used to identify this module when it is referenced. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this module definition is (or will be) published.
+ */
+ @Child(name = "url", type = {UriType.class}, order=0, min=0, max=1, modifier=false, summary=true)
+ @Description(shortDefinition="Logical URL to reference this module", formalDefinition="An absolute URL that is used to identify this module when it is referenced. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this module definition is (or will be) published." )
+ protected UriType url;
+
+ /**
+ * A logical identifier for the module such as the CMS or NQF identifiers for a measure artifact.
+ */
+ @Child(name = "identifier", type = {Identifier.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Description(shortDefinition="Logical identifier(s) for the module", formalDefinition="A logical identifier for the module such as the CMS or NQF identifiers for a measure artifact." )
+ protected List identifier;
+
+ /**
+ * The version of the module, if any. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge modules, refer to the Decision Support Service specification. Note that the version is required for non-experimental published artifact.
+ */
+ @Child(name = "version", type = {StringType.class}, order=2, min=0, max=1, modifier=false, summary=true)
+ @Description(shortDefinition="The version of the module, if any", formalDefinition="The version of the module, if any. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge modules, refer to the Decision Support Service specification. Note that the version is required for non-experimental published artifact." )
+ protected StringType version;
+
+ /**
+ * A machine-friendly name for the module. This name should be usable as an identifier for the module by machine processing applications such as code generation.
+ */
+ @Child(name = "name", type = {StringType.class}, order=3, min=0, max=1, modifier=false, summary=true)
+ @Description(shortDefinition="A machine-friendly name for the module", formalDefinition="A machine-friendly name for the module. This name should be usable as an identifier for the module by machine processing applications such as code generation." )
+ protected StringType name;
+
+ /**
+ * A short, descriptive, user-friendly title for the module.
+ */
+ @Child(name = "title", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=true)
+ @Description(shortDefinition="A user-friendly title for the module", formalDefinition="A short, descriptive, user-friendly title for the module." )
+ protected StringType title;
+
+ /**
+ * The status of the module.
+ */
+ @Child(name = "status", type = {CodeType.class}, order=5, min=1, max=1, modifier=true, summary=true)
+ @Description(shortDefinition="draft | active | inactive", formalDefinition="The status of the module." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/module-metadata-status")
+ protected CodeType status;
+
+ /**
+ * Determines whether the module was developed for testing purposes (or education/evaluation/marketing), and is not intended to be used in production environments.
+ */
+ @Child(name = "experimental", type = {BooleanType.class}, order=6, min=0, max=1, modifier=true, summary=true)
+ @Description(shortDefinition="If for testing purposes, not real usage", formalDefinition="Determines whether the module was developed for testing purposes (or education/evaluation/marketing), and is not intended to be used in production environments." )
+ protected BooleanType experimental;
+
+ /**
+ * A free text natural language description of the module from the consumer's perspective.
+ */
+ @Child(name = "description", type = {StringType.class}, order=7, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Natural language description of the module", formalDefinition="A free text natural language description of the module from the consumer's perspective." )
+ protected StringType description;
+
+ /**
+ * A brief description of the purpose of the module.
+ */
+ @Child(name = "purpose", type = {StringType.class}, order=8, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Describes the purpose of the module", formalDefinition="A brief description of the purpose of the module." )
+ protected StringType purpose;
+
+ /**
+ * A detailed description of how the module is used from a clinical perspective.
+ */
+ @Child(name = "usage", type = {StringType.class}, order=9, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Describes the clinical usage of the module", formalDefinition="A detailed description of how the module is used from a clinical perspective." )
+ protected StringType usage;
+
+ /**
+ * The date on which the module was published.
+ */
+ @Child(name = "publicationDate", type = {DateType.class}, order=10, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Publication date for this version of the module", formalDefinition="The date on which the module was published." )
+ protected DateType publicationDate;
+
+ /**
+ * The date on which the module content was last reviewed.
+ */
+ @Child(name = "lastReviewDate", type = {DateType.class}, order=11, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Last review date for the module", formalDefinition="The date on which the module content was last reviewed." )
+ protected DateType lastReviewDate;
+
+ /**
+ * The period during which the module content is effective.
+ */
+ @Child(name = "effectivePeriod", type = {Period.class}, order=12, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="The effective date range for the module", formalDefinition="The period during which the module content is effective." )
+ protected Period effectivePeriod;
+
+ /**
+ * Specifies various attributes of the patient population for whom and/or environment of care in which, the knowledge module is applicable.
+ */
+ @Child(name = "coverage", type = {UsageContext.class}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="Describes the context of use for this module", formalDefinition="Specifies various attributes of the patient population for whom and/or environment of care in which, the knowledge module is applicable." )
+ protected List coverage;
+
+ /**
+ * Clinical topics related to the content of the module.
+ */
+ @Child(name = "topic", type = {CodeableConcept.class}, order=14, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="Descriptional topics for the module", formalDefinition="Clinical topics related to the content of the module." )
+ protected List topic;
+
+ /**
+ * A contributor to the content of the module, including authors, editors, reviewers, and endorsers.
+ */
+ @Child(name = "contributor", type = {Contributor.class}, order=15, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="A content contributor", formalDefinition="A contributor to the content of the module, including authors, editors, reviewers, and endorsers." )
+ protected List contributor;
+
+ /**
+ * The name of the individual or organization that published the module (also known as the steward for the module). This information is required for non-experimental published artifacts.
+ */
+ @Child(name = "publisher", type = {StringType.class}, order=16, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Name of the publisher (Organization or individual)", formalDefinition="The name of the individual or organization that published the module (also known as the steward for the module). This information is required for non-experimental published artifacts." )
+ protected StringType publisher;
+
+ /**
+ * Contact details to assist a user in finding and communicating with the publisher.
+ */
+ @Child(name = "contact", type = {ContactDetail.class}, order=17, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="Contact details of the publisher", formalDefinition="Contact details to assist a user in finding and communicating with the publisher." )
+ protected List contact;
+
+ /**
+ * A copyright statement relating to the module and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the module.
+ */
+ @Child(name = "copyright", type = {StringType.class}, order=18, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Use and/or publishing restrictions", formalDefinition="A copyright statement relating to the module and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the module." )
+ protected StringType copyright;
+
+ /**
+ * Related resources such as additional documentation, justification, or bibliographic references.
+ */
+ @Child(name = "relatedResource", type = {RelatedResource.class}, order=19, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="Related resources for the module", formalDefinition="Related resources such as additional documentation, justification, or bibliographic references." )
+ protected List relatedResource;
+
+ /**
+ * A reference to a Library resource containing any formal logic used by the orderset.
+ */
+ @Child(name = "library", type = {Library.class}, order=20, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="Logic used by the plan definition", formalDefinition="A reference to a Library resource containing any formal logic used by the orderset." )
+ protected List library;
+ /**
+ * The actual objects that are the target of the reference (A reference to a Library resource containing any formal logic used by the orderset.)
+ */
+ protected List libraryTarget;
+
+
+ /**
+ * High-level categorization of the type of activity.
+ */
+ @Child(name = "category", type = {CodeType.class}, order=21, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="communication | diet | drug | encounter | observation | procedure | referral | supply | other", formalDefinition="High-level categorization of the type of activity." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/activity-definition-category")
+ protected Enumeration category;
+
+ /**
+ * Detailed description of the type of activity; e.g. What lab test, what procedure, what kind of encounter.
+ */
+ @Child(name = "code", type = {CodeableConcept.class}, order=22, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Detail type of activity", formalDefinition="Detailed description of the type of activity; e.g. What lab test, what procedure, what kind of encounter." )
+ protected CodeableConcept code;
+
+ /**
+ * The period, timing or frequency upon which the described activity is to occur.
+ */
+ @Child(name = "timing", type = {CodeableConcept.class, Timing.class}, order=23, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="When activity is to occur", formalDefinition="The period, timing or frequency upon which the described activity is to occur." )
+ protected Type timing;
+
+ /**
+ * Identifies the facility where the activity will occur; e.g. home, hospital, specific clinic, etc.
+ */
+ @Child(name = "location", type = {Location.class}, order=24, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Where it should happen", formalDefinition="Identifies the facility where the activity will occur; e.g. home, hospital, specific clinic, etc." )
+ protected Reference location;
+
+ /**
+ * The actual object that is the target of the reference (Identifies the facility where the activity will occur; e.g. home, hospital, specific clinic, etc.)
+ */
+ protected Location locationTarget;
+
+ /**
+ * The type of participant in the action.
+ */
+ @Child(name = "participantType", type = {CodeType.class}, order=25, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="patient | practitioner | related-person", formalDefinition="The type of participant in the action." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/activity-participant-type")
+ protected List> participantType;
+
+ /**
+ * Identifies the food, drug or other product being consumed or supplied in the activity.
+ */
+ @Child(name = "product", type = {Medication.class, Substance.class, CodeableConcept.class}, order=26, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="What's administered/supplied", formalDefinition="Identifies the food, drug or other product being consumed or supplied in the activity." )
+ protected Type product;
+
+ /**
+ * Identifies the quantity expected to be consumed at once (per dose, per meal, etc.).
+ */
+ @Child(name = "quantity", type = {SimpleQuantity.class}, order=27, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="How much is administered/consumed/supplied", formalDefinition="Identifies the quantity expected to be consumed at once (per dose, per meal, etc.)." )
+ protected SimpleQuantity quantity;
+
+ private static final long serialVersionUID = -1624469573L;
+
+ /**
+ * Constructor
+ */
+ public ActivityDefinition() {
+ super();
+ }
+
+ /**
+ * Constructor
+ */
+ public ActivityDefinition(CodeType status) {
+ super();
+ this.status = status;
+ }
+
+ /**
+ * @return {@link #url} (An absolute URL that is used to identify this module when it is referenced. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this module definition is (or will be) published.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
+ */
+ public UriType getUrlElement() {
+ if (this.url == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.url");
+ else if (Configuration.doAutoCreate())
+ this.url = new UriType(); // bb
+ return this.url;
+ }
+
+ public boolean hasUrlElement() {
+ return this.url != null && !this.url.isEmpty();
+ }
+
+ public boolean hasUrl() {
+ return this.url != null && !this.url.isEmpty();
+ }
+
+ /**
+ * @param value {@link #url} (An absolute URL that is used to identify this module when it is referenced. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this module definition is (or will be) published.). This is the underlying object with id, value and extensions. The accessor "getUrl" gives direct access to the value
+ */
+ public ActivityDefinition setUrlElement(UriType value) {
+ this.url = value;
+ return this;
+ }
+
+ /**
+ * @return An absolute URL that is used to identify this module when it is referenced. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this module definition is (or will be) published.
+ */
+ public String getUrl() {
+ return this.url == null ? null : this.url.getValue();
+ }
+
+ /**
+ * @param value An absolute URL that is used to identify this module when it is referenced. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this module definition is (or will be) published.
+ */
+ public ActivityDefinition setUrl(String value) {
+ if (Utilities.noString(value))
+ this.url = null;
+ else {
+ if (this.url == null)
+ this.url = new UriType();
+ this.url.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #identifier} (A logical identifier for the module such as the CMS or NQF identifiers for a measure artifact.)
+ */
+ public List getIdentifier() {
+ if (this.identifier == null)
+ this.identifier = new ArrayList();
+ return this.identifier;
+ }
+
+ /**
+ * @return Returns a reference to this
for easy method chaining
+ */
+ public ActivityDefinition setIdentifier(List theIdentifier) {
+ this.identifier = theIdentifier;
+ return this;
+ }
+
+ public boolean hasIdentifier() {
+ if (this.identifier == null)
+ return false;
+ for (Identifier item : this.identifier)
+ if (!item.isEmpty())
+ return true;
+ return false;
+ }
+
+ public Identifier addIdentifier() { //3
+ Identifier t = new Identifier();
+ if (this.identifier == null)
+ this.identifier = new ArrayList();
+ this.identifier.add(t);
+ return t;
+ }
+
+ public ActivityDefinition addIdentifier(Identifier t) { //3
+ if (t == null)
+ return this;
+ if (this.identifier == null)
+ this.identifier = new ArrayList();
+ this.identifier.add(t);
+ return this;
+ }
+
+ /**
+ * @return The first repetition of repeating field {@link #identifier}, creating it if it does not already exist
+ */
+ public Identifier getIdentifierFirstRep() {
+ if (getIdentifier().isEmpty()) {
+ addIdentifier();
+ }
+ return getIdentifier().get(0);
+ }
+
+ /**
+ * @return {@link #version} (The version of the module, if any. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge modules, refer to the Decision Support Service specification. Note that the version is required for non-experimental published artifact.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
+ */
+ public StringType getVersionElement() {
+ if (this.version == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.version");
+ else if (Configuration.doAutoCreate())
+ this.version = new StringType(); // bb
+ return this.version;
+ }
+
+ public boolean hasVersionElement() {
+ return this.version != null && !this.version.isEmpty();
+ }
+
+ public boolean hasVersion() {
+ return this.version != null && !this.version.isEmpty();
+ }
+
+ /**
+ * @param value {@link #version} (The version of the module, if any. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge modules, refer to the Decision Support Service specification. Note that the version is required for non-experimental published artifact.). This is the underlying object with id, value and extensions. The accessor "getVersion" gives direct access to the value
+ */
+ public ActivityDefinition setVersionElement(StringType value) {
+ this.version = value;
+ return this;
+ }
+
+ /**
+ * @return The version of the module, if any. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge modules, refer to the Decision Support Service specification. Note that the version is required for non-experimental published artifact.
+ */
+ public String getVersion() {
+ return this.version == null ? null : this.version.getValue();
+ }
+
+ /**
+ * @param value The version of the module, if any. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge modules, refer to the Decision Support Service specification. Note that the version is required for non-experimental published artifact.
+ */
+ public ActivityDefinition setVersion(String value) {
+ if (Utilities.noString(value))
+ this.version = null;
+ else {
+ if (this.version == null)
+ this.version = new StringType();
+ this.version.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #name} (A machine-friendly name for the module. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
+ */
+ public StringType getNameElement() {
+ if (this.name == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.name");
+ else if (Configuration.doAutoCreate())
+ this.name = new StringType(); // bb
+ return this.name;
+ }
+
+ public boolean hasNameElement() {
+ return this.name != null && !this.name.isEmpty();
+ }
+
+ public boolean hasName() {
+ return this.name != null && !this.name.isEmpty();
+ }
+
+ /**
+ * @param value {@link #name} (A machine-friendly name for the module. This name should be usable as an identifier for the module by machine processing applications such as code generation.). This is the underlying object with id, value and extensions. The accessor "getName" gives direct access to the value
+ */
+ public ActivityDefinition setNameElement(StringType value) {
+ this.name = value;
+ return this;
+ }
+
+ /**
+ * @return A machine-friendly name for the module. This name should be usable as an identifier for the module by machine processing applications such as code generation.
+ */
+ public String getName() {
+ return this.name == null ? null : this.name.getValue();
+ }
+
+ /**
+ * @param value A machine-friendly name for the module. This name should be usable as an identifier for the module by machine processing applications such as code generation.
+ */
+ public ActivityDefinition setName(String value) {
+ if (Utilities.noString(value))
+ this.name = null;
+ else {
+ if (this.name == null)
+ this.name = new StringType();
+ this.name.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #title} (A short, descriptive, user-friendly title for the module.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
+ */
+ public StringType getTitleElement() {
+ if (this.title == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.title");
+ else if (Configuration.doAutoCreate())
+ this.title = new StringType(); // bb
+ return this.title;
+ }
+
+ public boolean hasTitleElement() {
+ return this.title != null && !this.title.isEmpty();
+ }
+
+ public boolean hasTitle() {
+ return this.title != null && !this.title.isEmpty();
+ }
+
+ /**
+ * @param value {@link #title} (A short, descriptive, user-friendly title for the module.). This is the underlying object with id, value and extensions. The accessor "getTitle" gives direct access to the value
+ */
+ public ActivityDefinition setTitleElement(StringType value) {
+ this.title = value;
+ return this;
+ }
+
+ /**
+ * @return A short, descriptive, user-friendly title for the module.
+ */
+ public String getTitle() {
+ return this.title == null ? null : this.title.getValue();
+ }
+
+ /**
+ * @param value A short, descriptive, user-friendly title for the module.
+ */
+ public ActivityDefinition setTitle(String value) {
+ if (Utilities.noString(value))
+ this.title = null;
+ else {
+ if (this.title == null)
+ this.title = new StringType();
+ this.title.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #status} (The status of the module.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
+ */
+ public CodeType getStatusElement() {
+ if (this.status == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.status");
+ else if (Configuration.doAutoCreate())
+ this.status = new CodeType(); // bb
+ return this.status;
+ }
+
+ public boolean hasStatusElement() {
+ return this.status != null && !this.status.isEmpty();
+ }
+
+ public boolean hasStatus() {
+ return this.status != null && !this.status.isEmpty();
+ }
+
+ /**
+ * @param value {@link #status} (The status of the module.). This is the underlying object with id, value and extensions. The accessor "getStatus" gives direct access to the value
+ */
+ public ActivityDefinition setStatusElement(CodeType value) {
+ this.status = value;
+ return this;
+ }
+
+ /**
+ * @return The status of the module.
+ */
+ public String getStatus() {
+ return this.status == null ? null : this.status.getValue();
+ }
+
+ /**
+ * @param value The status of the module.
+ */
+ public ActivityDefinition setStatus(String value) {
+ if (this.status == null)
+ this.status = new CodeType();
+ this.status.setValue(value);
+ return this;
+ }
+
+ /**
+ * @return {@link #experimental} (Determines whether the module was developed for testing purposes (or education/evaluation/marketing), and is not intended to be used in production environments.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value
+ */
+ public BooleanType getExperimentalElement() {
+ if (this.experimental == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.experimental");
+ else if (Configuration.doAutoCreate())
+ this.experimental = new BooleanType(); // bb
+ return this.experimental;
+ }
+
+ public boolean hasExperimentalElement() {
+ return this.experimental != null && !this.experimental.isEmpty();
+ }
+
+ public boolean hasExperimental() {
+ return this.experimental != null && !this.experimental.isEmpty();
+ }
+
+ /**
+ * @param value {@link #experimental} (Determines whether the module was developed for testing purposes (or education/evaluation/marketing), and is not intended to be used in production environments.). This is the underlying object with id, value and extensions. The accessor "getExperimental" gives direct access to the value
+ */
+ public ActivityDefinition setExperimentalElement(BooleanType value) {
+ this.experimental = value;
+ return this;
+ }
+
+ /**
+ * @return Determines whether the module was developed for testing purposes (or education/evaluation/marketing), and is not intended to be used in production environments.
+ */
+ public boolean getExperimental() {
+ return this.experimental == null || this.experimental.isEmpty() ? false : this.experimental.getValue();
+ }
+
+ /**
+ * @param value Determines whether the module was developed for testing purposes (or education/evaluation/marketing), and is not intended to be used in production environments.
+ */
+ public ActivityDefinition setExperimental(boolean value) {
+ if (this.experimental == null)
+ this.experimental = new BooleanType();
+ this.experimental.setValue(value);
+ return this;
+ }
+
+ /**
+ * @return {@link #description} (A free text natural language description of the module from the consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
+ */
+ public StringType getDescriptionElement() {
+ if (this.description == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.description");
+ else if (Configuration.doAutoCreate())
+ this.description = new StringType(); // bb
+ return this.description;
+ }
+
+ public boolean hasDescriptionElement() {
+ return this.description != null && !this.description.isEmpty();
+ }
+
+ public boolean hasDescription() {
+ return this.description != null && !this.description.isEmpty();
+ }
+
+ /**
+ * @param value {@link #description} (A free text natural language description of the module from the consumer's perspective.). This is the underlying object with id, value and extensions. The accessor "getDescription" gives direct access to the value
+ */
+ public ActivityDefinition setDescriptionElement(StringType value) {
+ this.description = value;
+ return this;
+ }
+
+ /**
+ * @return A free text natural language description of the module from the consumer's perspective.
+ */
+ public String getDescription() {
+ return this.description == null ? null : this.description.getValue();
+ }
+
+ /**
+ * @param value A free text natural language description of the module from the consumer's perspective.
+ */
+ public ActivityDefinition setDescription(String value) {
+ if (Utilities.noString(value))
+ this.description = null;
+ else {
+ if (this.description == null)
+ this.description = new StringType();
+ this.description.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #purpose} (A brief description of the purpose of the module.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value
+ */
+ public StringType getPurposeElement() {
+ if (this.purpose == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.purpose");
+ else if (Configuration.doAutoCreate())
+ this.purpose = new StringType(); // bb
+ return this.purpose;
+ }
+
+ public boolean hasPurposeElement() {
+ return this.purpose != null && !this.purpose.isEmpty();
+ }
+
+ public boolean hasPurpose() {
+ return this.purpose != null && !this.purpose.isEmpty();
+ }
+
+ /**
+ * @param value {@link #purpose} (A brief description of the purpose of the module.). This is the underlying object with id, value and extensions. The accessor "getPurpose" gives direct access to the value
+ */
+ public ActivityDefinition setPurposeElement(StringType value) {
+ this.purpose = value;
+ return this;
+ }
+
+ /**
+ * @return A brief description of the purpose of the module.
+ */
+ public String getPurpose() {
+ return this.purpose == null ? null : this.purpose.getValue();
+ }
+
+ /**
+ * @param value A brief description of the purpose of the module.
+ */
+ public ActivityDefinition setPurpose(String value) {
+ if (Utilities.noString(value))
+ this.purpose = null;
+ else {
+ if (this.purpose == null)
+ this.purpose = new StringType();
+ this.purpose.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #usage} (A detailed description of how the module is used from a clinical perspective.). This is the underlying object with id, value and extensions. The accessor "getUsage" gives direct access to the value
+ */
+ public StringType getUsageElement() {
+ if (this.usage == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.usage");
+ else if (Configuration.doAutoCreate())
+ this.usage = new StringType(); // bb
+ return this.usage;
+ }
+
+ public boolean hasUsageElement() {
+ return this.usage != null && !this.usage.isEmpty();
+ }
+
+ public boolean hasUsage() {
+ return this.usage != null && !this.usage.isEmpty();
+ }
+
+ /**
+ * @param value {@link #usage} (A detailed description of how the module is used from a clinical perspective.). This is the underlying object with id, value and extensions. The accessor "getUsage" gives direct access to the value
+ */
+ public ActivityDefinition setUsageElement(StringType value) {
+ this.usage = value;
+ return this;
+ }
+
+ /**
+ * @return A detailed description of how the module is used from a clinical perspective.
+ */
+ public String getUsage() {
+ return this.usage == null ? null : this.usage.getValue();
+ }
+
+ /**
+ * @param value A detailed description of how the module is used from a clinical perspective.
+ */
+ public ActivityDefinition setUsage(String value) {
+ if (Utilities.noString(value))
+ this.usage = null;
+ else {
+ if (this.usage == null)
+ this.usage = new StringType();
+ this.usage.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #publicationDate} (The date on which the module was published.). This is the underlying object with id, value and extensions. The accessor "getPublicationDate" gives direct access to the value
+ */
+ public DateType getPublicationDateElement() {
+ if (this.publicationDate == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.publicationDate");
+ else if (Configuration.doAutoCreate())
+ this.publicationDate = new DateType(); // bb
+ return this.publicationDate;
+ }
+
+ public boolean hasPublicationDateElement() {
+ return this.publicationDate != null && !this.publicationDate.isEmpty();
+ }
+
+ public boolean hasPublicationDate() {
+ return this.publicationDate != null && !this.publicationDate.isEmpty();
+ }
+
+ /**
+ * @param value {@link #publicationDate} (The date on which the module was published.). This is the underlying object with id, value and extensions. The accessor "getPublicationDate" gives direct access to the value
+ */
+ public ActivityDefinition setPublicationDateElement(DateType value) {
+ this.publicationDate = value;
+ return this;
+ }
+
+ /**
+ * @return The date on which the module was published.
+ */
+ public Date getPublicationDate() {
+ return this.publicationDate == null ? null : this.publicationDate.getValue();
+ }
+
+ /**
+ * @param value The date on which the module was published.
+ */
+ public ActivityDefinition setPublicationDate(Date value) {
+ if (value == null)
+ this.publicationDate = null;
+ else {
+ if (this.publicationDate == null)
+ this.publicationDate = new DateType();
+ this.publicationDate.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #lastReviewDate} (The date on which the module content was last reviewed.). This is the underlying object with id, value and extensions. The accessor "getLastReviewDate" gives direct access to the value
+ */
+ public DateType getLastReviewDateElement() {
+ if (this.lastReviewDate == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.lastReviewDate");
+ else if (Configuration.doAutoCreate())
+ this.lastReviewDate = new DateType(); // bb
+ return this.lastReviewDate;
+ }
+
+ public boolean hasLastReviewDateElement() {
+ return this.lastReviewDate != null && !this.lastReviewDate.isEmpty();
+ }
+
+ public boolean hasLastReviewDate() {
+ return this.lastReviewDate != null && !this.lastReviewDate.isEmpty();
+ }
+
+ /**
+ * @param value {@link #lastReviewDate} (The date on which the module content was last reviewed.). This is the underlying object with id, value and extensions. The accessor "getLastReviewDate" gives direct access to the value
+ */
+ public ActivityDefinition setLastReviewDateElement(DateType value) {
+ this.lastReviewDate = value;
+ return this;
+ }
+
+ /**
+ * @return The date on which the module content was last reviewed.
+ */
+ public Date getLastReviewDate() {
+ return this.lastReviewDate == null ? null : this.lastReviewDate.getValue();
+ }
+
+ /**
+ * @param value The date on which the module content was last reviewed.
+ */
+ public ActivityDefinition setLastReviewDate(Date value) {
+ if (value == null)
+ this.lastReviewDate = null;
+ else {
+ if (this.lastReviewDate == null)
+ this.lastReviewDate = new DateType();
+ this.lastReviewDate.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #effectivePeriod} (The period during which the module content is effective.)
+ */
+ public Period getEffectivePeriod() {
+ if (this.effectivePeriod == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.effectivePeriod");
+ else if (Configuration.doAutoCreate())
+ this.effectivePeriod = new Period(); // cc
+ return this.effectivePeriod;
+ }
+
+ public boolean hasEffectivePeriod() {
+ return this.effectivePeriod != null && !this.effectivePeriod.isEmpty();
+ }
+
+ /**
+ * @param value {@link #effectivePeriod} (The period during which the module content is effective.)
+ */
+ public ActivityDefinition setEffectivePeriod(Period value) {
+ this.effectivePeriod = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #coverage} (Specifies various attributes of the patient population for whom and/or environment of care in which, the knowledge module is applicable.)
+ */
+ public List getCoverage() {
+ if (this.coverage == null)
+ this.coverage = new ArrayList();
+ return this.coverage;
+ }
+
+ /**
+ * @return Returns a reference to this
for easy method chaining
+ */
+ public ActivityDefinition setCoverage(List theCoverage) {
+ this.coverage = theCoverage;
+ return this;
+ }
+
+ public boolean hasCoverage() {
+ if (this.coverage == null)
+ return false;
+ for (UsageContext item : this.coverage)
+ if (!item.isEmpty())
+ return true;
+ return false;
+ }
+
+ public UsageContext addCoverage() { //3
+ UsageContext t = new UsageContext();
+ if (this.coverage == null)
+ this.coverage = new ArrayList();
+ this.coverage.add(t);
+ return t;
+ }
+
+ public ActivityDefinition addCoverage(UsageContext t) { //3
+ if (t == null)
+ return this;
+ if (this.coverage == null)
+ this.coverage = new ArrayList();
+ this.coverage.add(t);
+ return this;
+ }
+
+ /**
+ * @return The first repetition of repeating field {@link #coverage}, creating it if it does not already exist
+ */
+ public UsageContext getCoverageFirstRep() {
+ if (getCoverage().isEmpty()) {
+ addCoverage();
+ }
+ return getCoverage().get(0);
+ }
+
+ /**
+ * @return {@link #topic} (Clinical topics related to the content of the module.)
+ */
+ public List getTopic() {
+ if (this.topic == null)
+ this.topic = new ArrayList();
+ return this.topic;
+ }
+
+ /**
+ * @return Returns a reference to this
for easy method chaining
+ */
+ public ActivityDefinition setTopic(List theTopic) {
+ this.topic = theTopic;
+ return this;
+ }
+
+ public boolean hasTopic() {
+ if (this.topic == null)
+ return false;
+ for (CodeableConcept item : this.topic)
+ if (!item.isEmpty())
+ return true;
+ return false;
+ }
+
+ public CodeableConcept addTopic() { //3
+ CodeableConcept t = new CodeableConcept();
+ if (this.topic == null)
+ this.topic = new ArrayList();
+ this.topic.add(t);
+ return t;
+ }
+
+ public ActivityDefinition addTopic(CodeableConcept t) { //3
+ if (t == null)
+ return this;
+ if (this.topic == null)
+ this.topic = new ArrayList();
+ this.topic.add(t);
+ return this;
+ }
+
+ /**
+ * @return The first repetition of repeating field {@link #topic}, creating it if it does not already exist
+ */
+ public CodeableConcept getTopicFirstRep() {
+ if (getTopic().isEmpty()) {
+ addTopic();
+ }
+ return getTopic().get(0);
+ }
+
+ /**
+ * @return {@link #contributor} (A contributor to the content of the module, including authors, editors, reviewers, and endorsers.)
+ */
+ public List getContributor() {
+ if (this.contributor == null)
+ this.contributor = new ArrayList();
+ return this.contributor;
+ }
+
+ /**
+ * @return Returns a reference to this
for easy method chaining
+ */
+ public ActivityDefinition setContributor(List theContributor) {
+ this.contributor = theContributor;
+ return this;
+ }
+
+ public boolean hasContributor() {
+ if (this.contributor == null)
+ return false;
+ for (Contributor item : this.contributor)
+ if (!item.isEmpty())
+ return true;
+ return false;
+ }
+
+ public Contributor addContributor() { //3
+ Contributor t = new Contributor();
+ if (this.contributor == null)
+ this.contributor = new ArrayList();
+ this.contributor.add(t);
+ return t;
+ }
+
+ public ActivityDefinition addContributor(Contributor t) { //3
+ if (t == null)
+ return this;
+ if (this.contributor == null)
+ this.contributor = new ArrayList();
+ this.contributor.add(t);
+ return this;
+ }
+
+ /**
+ * @return The first repetition of repeating field {@link #contributor}, creating it if it does not already exist
+ */
+ public Contributor getContributorFirstRep() {
+ if (getContributor().isEmpty()) {
+ addContributor();
+ }
+ return getContributor().get(0);
+ }
+
+ /**
+ * @return {@link #publisher} (The name of the individual or organization that published the module (also known as the steward for the module). This information is required for non-experimental published artifacts.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
+ */
+ public StringType getPublisherElement() {
+ if (this.publisher == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.publisher");
+ else if (Configuration.doAutoCreate())
+ this.publisher = new StringType(); // bb
+ return this.publisher;
+ }
+
+ public boolean hasPublisherElement() {
+ return this.publisher != null && !this.publisher.isEmpty();
+ }
+
+ public boolean hasPublisher() {
+ return this.publisher != null && !this.publisher.isEmpty();
+ }
+
+ /**
+ * @param value {@link #publisher} (The name of the individual or organization that published the module (also known as the steward for the module). This information is required for non-experimental published artifacts.). This is the underlying object with id, value and extensions. The accessor "getPublisher" gives direct access to the value
+ */
+ public ActivityDefinition setPublisherElement(StringType value) {
+ this.publisher = value;
+ return this;
+ }
+
+ /**
+ * @return The name of the individual or organization that published the module (also known as the steward for the module). This information is required for non-experimental published artifacts.
+ */
+ public String getPublisher() {
+ return this.publisher == null ? null : this.publisher.getValue();
+ }
+
+ /**
+ * @param value The name of the individual or organization that published the module (also known as the steward for the module). This information is required for non-experimental published artifacts.
+ */
+ public ActivityDefinition setPublisher(String value) {
+ if (Utilities.noString(value))
+ this.publisher = null;
+ else {
+ if (this.publisher == null)
+ this.publisher = new StringType();
+ this.publisher.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #contact} (Contact details to assist a user in finding and communicating with the publisher.)
+ */
+ public List getContact() {
+ if (this.contact == null)
+ this.contact = new ArrayList();
+ return this.contact;
+ }
+
+ /**
+ * @return Returns a reference to this
for easy method chaining
+ */
+ public ActivityDefinition setContact(List theContact) {
+ this.contact = theContact;
+ return this;
+ }
+
+ public boolean hasContact() {
+ if (this.contact == null)
+ return false;
+ for (ContactDetail item : this.contact)
+ if (!item.isEmpty())
+ return true;
+ return false;
+ }
+
+ public ContactDetail addContact() { //3
+ ContactDetail t = new ContactDetail();
+ if (this.contact == null)
+ this.contact = new ArrayList();
+ this.contact.add(t);
+ return t;
+ }
+
+ public ActivityDefinition addContact(ContactDetail t) { //3
+ if (t == null)
+ return this;
+ if (this.contact == null)
+ this.contact = new ArrayList();
+ this.contact.add(t);
+ return this;
+ }
+
+ /**
+ * @return The first repetition of repeating field {@link #contact}, creating it if it does not already exist
+ */
+ public ContactDetail getContactFirstRep() {
+ if (getContact().isEmpty()) {
+ addContact();
+ }
+ return getContact().get(0);
+ }
+
+ /**
+ * @return {@link #copyright} (A copyright statement relating to the module and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the module.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
+ */
+ public StringType getCopyrightElement() {
+ if (this.copyright == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.copyright");
+ else if (Configuration.doAutoCreate())
+ this.copyright = new StringType(); // bb
+ return this.copyright;
+ }
+
+ public boolean hasCopyrightElement() {
+ return this.copyright != null && !this.copyright.isEmpty();
+ }
+
+ public boolean hasCopyright() {
+ return this.copyright != null && !this.copyright.isEmpty();
+ }
+
+ /**
+ * @param value {@link #copyright} (A copyright statement relating to the module and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the module.). This is the underlying object with id, value and extensions. The accessor "getCopyright" gives direct access to the value
+ */
+ public ActivityDefinition setCopyrightElement(StringType value) {
+ this.copyright = value;
+ return this;
+ }
+
+ /**
+ * @return A copyright statement relating to the module and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the module.
+ */
+ public String getCopyright() {
+ return this.copyright == null ? null : this.copyright.getValue();
+ }
+
+ /**
+ * @param value A copyright statement relating to the module and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the module.
+ */
+ public ActivityDefinition setCopyright(String value) {
+ if (Utilities.noString(value))
+ this.copyright = null;
+ else {
+ if (this.copyright == null)
+ this.copyright = new StringType();
+ this.copyright.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #relatedResource} (Related resources such as additional documentation, justification, or bibliographic references.)
+ */
+ public List getRelatedResource() {
+ if (this.relatedResource == null)
+ this.relatedResource = new ArrayList();
+ return this.relatedResource;
+ }
+
+ /**
+ * @return Returns a reference to this
for easy method chaining
+ */
+ public ActivityDefinition setRelatedResource(List theRelatedResource) {
+ this.relatedResource = theRelatedResource;
+ return this;
+ }
+
+ public boolean hasRelatedResource() {
+ if (this.relatedResource == null)
+ return false;
+ for (RelatedResource item : this.relatedResource)
+ if (!item.isEmpty())
+ return true;
+ return false;
+ }
+
+ public RelatedResource addRelatedResource() { //3
+ RelatedResource t = new RelatedResource();
+ if (this.relatedResource == null)
+ this.relatedResource = new ArrayList();
+ this.relatedResource.add(t);
+ return t;
+ }
+
+ public ActivityDefinition addRelatedResource(RelatedResource t) { //3
+ if (t == null)
+ return this;
+ if (this.relatedResource == null)
+ this.relatedResource = new ArrayList();
+ this.relatedResource.add(t);
+ return this;
+ }
+
+ /**
+ * @return The first repetition of repeating field {@link #relatedResource}, creating it if it does not already exist
+ */
+ public RelatedResource getRelatedResourceFirstRep() {
+ if (getRelatedResource().isEmpty()) {
+ addRelatedResource();
+ }
+ return getRelatedResource().get(0);
+ }
+
+ /**
+ * @return {@link #library} (A reference to a Library resource containing any formal logic used by the orderset.)
+ */
+ public List getLibrary() {
+ if (this.library == null)
+ this.library = new ArrayList();
+ return this.library;
+ }
+
+ /**
+ * @return Returns a reference to this
for easy method chaining
+ */
+ public ActivityDefinition setLibrary(List theLibrary) {
+ this.library = theLibrary;
+ return this;
+ }
+
+ public boolean hasLibrary() {
+ if (this.library == null)
+ return false;
+ for (Reference item : this.library)
+ if (!item.isEmpty())
+ return true;
+ return false;
+ }
+
+ public Reference addLibrary() { //3
+ Reference t = new Reference();
+ if (this.library == null)
+ this.library = new ArrayList();
+ this.library.add(t);
+ return t;
+ }
+
+ public ActivityDefinition addLibrary(Reference t) { //3
+ if (t == null)
+ return this;
+ if (this.library == null)
+ this.library = new ArrayList();
+ this.library.add(t);
+ return this;
+ }
+
+ /**
+ * @return The first repetition of repeating field {@link #library}, creating it if it does not already exist
+ */
+ public Reference getLibraryFirstRep() {
+ if (getLibrary().isEmpty()) {
+ addLibrary();
+ }
+ return getLibrary().get(0);
+ }
+
+ /**
+ * @deprecated Use Reference#setResource(IBaseResource) instead
+ */
+ @Deprecated
+ public List getLibraryTarget() {
+ if (this.libraryTarget == null)
+ this.libraryTarget = new ArrayList();
+ return this.libraryTarget;
+ }
+
+ /**
+ * @deprecated Use Reference#setResource(IBaseResource) instead
+ */
+ @Deprecated
+ public Library addLibraryTarget() {
+ Library r = new Library();
+ if (this.libraryTarget == null)
+ this.libraryTarget = new ArrayList();
+ this.libraryTarget.add(r);
+ return r;
+ }
+
+ /**
+ * @return {@link #category} (High-level categorization of the type of activity.). This is the underlying object with id, value and extensions. The accessor "getCategory" gives direct access to the value
+ */
+ public Enumeration getCategoryElement() {
+ if (this.category == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.category");
+ else if (Configuration.doAutoCreate())
+ this.category = new Enumeration(new ActivityDefinitionCategoryEnumFactory()); // bb
+ return this.category;
+ }
+
+ public boolean hasCategoryElement() {
+ return this.category != null && !this.category.isEmpty();
+ }
+
+ public boolean hasCategory() {
+ return this.category != null && !this.category.isEmpty();
+ }
+
+ /**
+ * @param value {@link #category} (High-level categorization of the type of activity.). This is the underlying object with id, value and extensions. The accessor "getCategory" gives direct access to the value
+ */
+ public ActivityDefinition setCategoryElement(Enumeration value) {
+ this.category = value;
+ return this;
+ }
+
+ /**
+ * @return High-level categorization of the type of activity.
+ */
+ public ActivityDefinitionCategory getCategory() {
+ return this.category == null ? null : this.category.getValue();
+ }
+
+ /**
+ * @param value High-level categorization of the type of activity.
+ */
+ public ActivityDefinition setCategory(ActivityDefinitionCategory value) {
+ if (value == null)
+ this.category = null;
+ else {
+ if (this.category == null)
+ this.category = new Enumeration(new ActivityDefinitionCategoryEnumFactory());
+ this.category.setValue(value);
+ }
+ return this;
+ }
+
+ /**
+ * @return {@link #code} (Detailed description of the type of activity; e.g. What lab test, what procedure, what kind of encounter.)
+ */
+ public CodeableConcept getCode() {
+ if (this.code == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.code");
+ else if (Configuration.doAutoCreate())
+ this.code = new CodeableConcept(); // cc
+ return this.code;
+ }
+
+ public boolean hasCode() {
+ return this.code != null && !this.code.isEmpty();
+ }
+
+ /**
+ * @param value {@link #code} (Detailed description of the type of activity; e.g. What lab test, what procedure, what kind of encounter.)
+ */
+ public ActivityDefinition setCode(CodeableConcept value) {
+ this.code = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #timing} (The period, timing or frequency upon which the described activity is to occur.)
+ */
+ public Type getTiming() {
+ return this.timing;
+ }
+
+ /**
+ * @return {@link #timing} (The period, timing or frequency upon which the described activity is to occur.)
+ */
+ public CodeableConcept getTimingCodeableConcept() throws FHIRException {
+ if (!(this.timing instanceof CodeableConcept))
+ throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.timing.getClass().getName()+" was encountered");
+ return (CodeableConcept) this.timing;
+ }
+
+ public boolean hasTimingCodeableConcept() {
+ return this.timing instanceof CodeableConcept;
+ }
+
+ /**
+ * @return {@link #timing} (The period, timing or frequency upon which the described activity is to occur.)
+ */
+ public Timing getTimingTiming() throws FHIRException {
+ if (!(this.timing instanceof Timing))
+ throw new FHIRException("Type mismatch: the type Timing was expected, but "+this.timing.getClass().getName()+" was encountered");
+ return (Timing) this.timing;
+ }
+
+ public boolean hasTimingTiming() {
+ return this.timing instanceof Timing;
+ }
+
+ public boolean hasTiming() {
+ return this.timing != null && !this.timing.isEmpty();
+ }
+
+ /**
+ * @param value {@link #timing} (The period, timing or frequency upon which the described activity is to occur.)
+ */
+ public ActivityDefinition setTiming(Type value) {
+ this.timing = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #location} (Identifies the facility where the activity will occur; e.g. home, hospital, specific clinic, etc.)
+ */
+ public Reference getLocation() {
+ if (this.location == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.location");
+ else if (Configuration.doAutoCreate())
+ this.location = new Reference(); // cc
+ return this.location;
+ }
+
+ public boolean hasLocation() {
+ return this.location != null && !this.location.isEmpty();
+ }
+
+ /**
+ * @param value {@link #location} (Identifies the facility where the activity will occur; e.g. home, hospital, specific clinic, etc.)
+ */
+ public ActivityDefinition setLocation(Reference value) {
+ this.location = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #location} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Identifies the facility where the activity will occur; e.g. home, hospital, specific clinic, etc.)
+ */
+ public Location getLocationTarget() {
+ if (this.locationTarget == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.location");
+ else if (Configuration.doAutoCreate())
+ this.locationTarget = new Location(); // aa
+ return this.locationTarget;
+ }
+
+ /**
+ * @param value {@link #location} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Identifies the facility where the activity will occur; e.g. home, hospital, specific clinic, etc.)
+ */
+ public ActivityDefinition setLocationTarget(Location value) {
+ this.locationTarget = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #participantType} (The type of participant in the action.)
+ */
+ public List> getParticipantType() {
+ if (this.participantType == null)
+ this.participantType = new ArrayList>();
+ return this.participantType;
+ }
+
+ /**
+ * @return Returns a reference to this
for easy method chaining
+ */
+ public ActivityDefinition setParticipantType(List> theParticipantType) {
+ this.participantType = theParticipantType;
+ return this;
+ }
+
+ public boolean hasParticipantType() {
+ if (this.participantType == null)
+ return false;
+ for (Enumeration item : this.participantType)
+ if (!item.isEmpty())
+ return true;
+ return false;
+ }
+
+ /**
+ * @return {@link #participantType} (The type of participant in the action.)
+ */
+ public Enumeration addParticipantTypeElement() {//2
+ Enumeration t = new Enumeration(new ActivityParticipantTypeEnumFactory());
+ if (this.participantType == null)
+ this.participantType = new ArrayList>();
+ this.participantType.add(t);
+ return t;
+ }
+
+ /**
+ * @param value {@link #participantType} (The type of participant in the action.)
+ */
+ public ActivityDefinition addParticipantType(ActivityParticipantType value) { //1
+ Enumeration t = new Enumeration(new ActivityParticipantTypeEnumFactory());
+ t.setValue(value);
+ if (this.participantType == null)
+ this.participantType = new ArrayList>();
+ this.participantType.add(t);
+ return this;
+ }
+
+ /**
+ * @param value {@link #participantType} (The type of participant in the action.)
+ */
+ public boolean hasParticipantType(ActivityParticipantType value) {
+ if (this.participantType == null)
+ return false;
+ for (Enumeration v : this.participantType)
+ if (v.getValue().equals(value)) // code
+ return true;
+ return false;
+ }
+
+ /**
+ * @return {@link #product} (Identifies the food, drug or other product being consumed or supplied in the activity.)
+ */
+ public Type getProduct() {
+ return this.product;
+ }
+
+ /**
+ * @return {@link #product} (Identifies the food, drug or other product being consumed or supplied in the activity.)
+ */
+ public Reference getProductReference() throws FHIRException {
+ if (!(this.product instanceof Reference))
+ throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.product.getClass().getName()+" was encountered");
+ return (Reference) this.product;
+ }
+
+ public boolean hasProductReference() {
+ return this.product instanceof Reference;
+ }
+
+ /**
+ * @return {@link #product} (Identifies the food, drug or other product being consumed or supplied in the activity.)
+ */
+ public CodeableConcept getProductCodeableConcept() throws FHIRException {
+ if (!(this.product instanceof CodeableConcept))
+ throw new FHIRException("Type mismatch: the type CodeableConcept was expected, but "+this.product.getClass().getName()+" was encountered");
+ return (CodeableConcept) this.product;
+ }
+
+ public boolean hasProductCodeableConcept() {
+ return this.product instanceof CodeableConcept;
+ }
+
+ public boolean hasProduct() {
+ return this.product != null && !this.product.isEmpty();
+ }
+
+ /**
+ * @param value {@link #product} (Identifies the food, drug or other product being consumed or supplied in the activity.)
+ */
+ public ActivityDefinition setProduct(Type value) {
+ this.product = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #quantity} (Identifies the quantity expected to be consumed at once (per dose, per meal, etc.).)
+ */
+ public SimpleQuantity getQuantity() {
+ if (this.quantity == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ActivityDefinition.quantity");
+ else if (Configuration.doAutoCreate())
+ this.quantity = new SimpleQuantity(); // cc
+ return this.quantity;
+ }
+
+ public boolean hasQuantity() {
+ return this.quantity != null && !this.quantity.isEmpty();
+ }
+
+ /**
+ * @param value {@link #quantity} (Identifies the quantity expected to be consumed at once (per dose, per meal, etc.).)
+ */
+ public ActivityDefinition setQuantity(SimpleQuantity value) {
+ this.quantity = value;
+ return this;
+ }
+
+ protected void listChildren(List childrenList) {
+ super.listChildren(childrenList);
+ childrenList.add(new Property("url", "uri", "An absolute URL that is used to identify this module when it is referenced. This SHALL be a URL, SHOULD be globally unique, and SHOULD be an address at which this module definition is (or will be) published.", 0, java.lang.Integer.MAX_VALUE, url));
+ childrenList.add(new Property("identifier", "Identifier", "A logical identifier for the module such as the CMS or NQF identifiers for a measure artifact.", 0, java.lang.Integer.MAX_VALUE, identifier));
+ childrenList.add(new Property("version", "string", "The version of the module, if any. To provide a version consistent with the Decision Support Service specification, use the format Major.Minor.Revision (e.g. 1.0.0). For more information on versioning knowledge modules, refer to the Decision Support Service specification. Note that the version is required for non-experimental published artifact.", 0, java.lang.Integer.MAX_VALUE, version));
+ childrenList.add(new Property("name", "string", "A machine-friendly name for the module. This name should be usable as an identifier for the module by machine processing applications such as code generation.", 0, java.lang.Integer.MAX_VALUE, name));
+ childrenList.add(new Property("title", "string", "A short, descriptive, user-friendly title for the module.", 0, java.lang.Integer.MAX_VALUE, title));
+ childrenList.add(new Property("status", "code", "The status of the module.", 0, java.lang.Integer.MAX_VALUE, status));
+ childrenList.add(new Property("experimental", "boolean", "Determines whether the module was developed for testing purposes (or education/evaluation/marketing), and is not intended to be used in production environments.", 0, java.lang.Integer.MAX_VALUE, experimental));
+ childrenList.add(new Property("description", "string", "A free text natural language description of the module from the consumer's perspective.", 0, java.lang.Integer.MAX_VALUE, description));
+ childrenList.add(new Property("purpose", "string", "A brief description of the purpose of the module.", 0, java.lang.Integer.MAX_VALUE, purpose));
+ childrenList.add(new Property("usage", "string", "A detailed description of how the module is used from a clinical perspective.", 0, java.lang.Integer.MAX_VALUE, usage));
+ childrenList.add(new Property("publicationDate", "date", "The date on which the module was published.", 0, java.lang.Integer.MAX_VALUE, publicationDate));
+ childrenList.add(new Property("lastReviewDate", "date", "The date on which the module content was last reviewed.", 0, java.lang.Integer.MAX_VALUE, lastReviewDate));
+ childrenList.add(new Property("effectivePeriod", "Period", "The period during which the module content is effective.", 0, java.lang.Integer.MAX_VALUE, effectivePeriod));
+ childrenList.add(new Property("coverage", "UsageContext", "Specifies various attributes of the patient population for whom and/or environment of care in which, the knowledge module is applicable.", 0, java.lang.Integer.MAX_VALUE, coverage));
+ childrenList.add(new Property("topic", "CodeableConcept", "Clinical topics related to the content of the module.", 0, java.lang.Integer.MAX_VALUE, topic));
+ childrenList.add(new Property("contributor", "Contributor", "A contributor to the content of the module, including authors, editors, reviewers, and endorsers.", 0, java.lang.Integer.MAX_VALUE, contributor));
+ childrenList.add(new Property("publisher", "string", "The name of the individual or organization that published the module (also known as the steward for the module). This information is required for non-experimental published artifacts.", 0, java.lang.Integer.MAX_VALUE, publisher));
+ childrenList.add(new Property("contact", "ContactDetail", "Contact details to assist a user in finding and communicating with the publisher.", 0, java.lang.Integer.MAX_VALUE, contact));
+ childrenList.add(new Property("copyright", "string", "A copyright statement relating to the module and/or its contents. Copyright statements are generally legal restrictions on the use and publishing of the module.", 0, java.lang.Integer.MAX_VALUE, copyright));
+ childrenList.add(new Property("relatedResource", "RelatedResource", "Related resources such as additional documentation, justification, or bibliographic references.", 0, java.lang.Integer.MAX_VALUE, relatedResource));
+ childrenList.add(new Property("library", "Reference(Library)", "A reference to a Library resource containing any formal logic used by the orderset.", 0, java.lang.Integer.MAX_VALUE, library));
+ childrenList.add(new Property("category", "code", "High-level categorization of the type of activity.", 0, java.lang.Integer.MAX_VALUE, category));
+ childrenList.add(new Property("code", "CodeableConcept", "Detailed description of the type of activity; e.g. What lab test, what procedure, what kind of encounter.", 0, java.lang.Integer.MAX_VALUE, code));
+ childrenList.add(new Property("timing[x]", "CodeableConcept|Timing", "The period, timing or frequency upon which the described activity is to occur.", 0, java.lang.Integer.MAX_VALUE, timing));
+ childrenList.add(new Property("location", "Reference(Location)", "Identifies the facility where the activity will occur; e.g. home, hospital, specific clinic, etc.", 0, java.lang.Integer.MAX_VALUE, location));
+ childrenList.add(new Property("participantType", "code", "The type of participant in the action.", 0, java.lang.Integer.MAX_VALUE, participantType));
+ childrenList.add(new Property("product[x]", "Reference(Medication|Substance)|CodeableConcept", "Identifies the food, drug or other product being consumed or supplied in the activity.", 0, java.lang.Integer.MAX_VALUE, product));
+ childrenList.add(new Property("quantity", "SimpleQuantity", "Identifies the quantity expected to be consumed at once (per dose, per meal, etc.).", 0, java.lang.Integer.MAX_VALUE, quantity));
+ }
+
+ @Override
+ public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
+ switch (hash) {
+ case 116079: /*url*/ return this.url == null ? new Base[0] : new Base[] {this.url}; // UriType
+ case -1618432855: /*identifier*/ return this.identifier == null ? new Base[0] : this.identifier.toArray(new Base[this.identifier.size()]); // Identifier
+ case 351608024: /*version*/ return this.version == null ? new Base[0] : new Base[] {this.version}; // StringType
+ case 3373707: /*name*/ return this.name == null ? new Base[0] : new Base[] {this.name}; // StringType
+ case 110371416: /*title*/ return this.title == null ? new Base[0] : new Base[] {this.title}; // StringType
+ case -892481550: /*status*/ return this.status == null ? new Base[0] : new Base[] {this.status}; // CodeType
+ case -404562712: /*experimental*/ return this.experimental == null ? new Base[0] : new Base[] {this.experimental}; // BooleanType
+ case -1724546052: /*description*/ return this.description == null ? new Base[0] : new Base[] {this.description}; // StringType
+ case -220463842: /*purpose*/ return this.purpose == null ? new Base[0] : new Base[] {this.purpose}; // StringType
+ case 111574433: /*usage*/ return this.usage == null ? new Base[0] : new Base[] {this.usage}; // StringType
+ case 1470566394: /*publicationDate*/ return this.publicationDate == null ? new Base[0] : new Base[] {this.publicationDate}; // DateType
+ case -1687512484: /*lastReviewDate*/ return this.lastReviewDate == null ? new Base[0] : new Base[] {this.lastReviewDate}; // DateType
+ case -403934648: /*effectivePeriod*/ return this.effectivePeriod == null ? new Base[0] : new Base[] {this.effectivePeriod}; // Period
+ case -351767064: /*coverage*/ return this.coverage == null ? new Base[0] : this.coverage.toArray(new Base[this.coverage.size()]); // UsageContext
+ case 110546223: /*topic*/ return this.topic == null ? new Base[0] : this.topic.toArray(new Base[this.topic.size()]); // CodeableConcept
+ case -1895276325: /*contributor*/ return this.contributor == null ? new Base[0] : this.contributor.toArray(new Base[this.contributor.size()]); // Contributor
+ case 1447404028: /*publisher*/ return this.publisher == null ? new Base[0] : new Base[] {this.publisher}; // StringType
+ case 951526432: /*contact*/ return this.contact == null ? new Base[0] : this.contact.toArray(new Base[this.contact.size()]); // ContactDetail
+ case 1522889671: /*copyright*/ return this.copyright == null ? new Base[0] : new Base[] {this.copyright}; // StringType
+ case 1554540889: /*relatedResource*/ return this.relatedResource == null ? new Base[0] : this.relatedResource.toArray(new Base[this.relatedResource.size()]); // RelatedResource
+ case 166208699: /*library*/ return this.library == null ? new Base[0] : this.library.toArray(new Base[this.library.size()]); // Reference
+ case 50511102: /*category*/ return this.category == null ? new Base[0] : new Base[] {this.category}; // Enumeration
+ case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // CodeableConcept
+ case -873664438: /*timing*/ return this.timing == null ? new Base[0] : new Base[] {this.timing}; // Type
+ case 1901043637: /*location*/ return this.location == null ? new Base[0] : new Base[] {this.location}; // Reference
+ case 841294093: /*participantType*/ return this.participantType == null ? new Base[0] : this.participantType.toArray(new Base[this.participantType.size()]); // Enumeration
+ case -309474065: /*product*/ return this.product == null ? new Base[0] : new Base[] {this.product}; // Type
+ case -1285004149: /*quantity*/ return this.quantity == null ? new Base[0] : new Base[] {this.quantity}; // SimpleQuantity
+ default: return super.getProperty(hash, name, checkValid);
+ }
+
+ }
+
+ @Override
+ public void setProperty(int hash, String name, Base value) throws FHIRException {
+ switch (hash) {
+ case 116079: // url
+ this.url = castToUri(value); // UriType
+ break;
+ case -1618432855: // identifier
+ this.getIdentifier().add(castToIdentifier(value)); // Identifier
+ break;
+ case 351608024: // version
+ this.version = castToString(value); // StringType
+ break;
+ case 3373707: // name
+ this.name = castToString(value); // StringType
+ break;
+ case 110371416: // title
+ this.title = castToString(value); // StringType
+ break;
+ case -892481550: // status
+ this.status = castToCode(value); // CodeType
+ break;
+ case -404562712: // experimental
+ this.experimental = castToBoolean(value); // BooleanType
+ break;
+ case -1724546052: // description
+ this.description = castToString(value); // StringType
+ break;
+ case -220463842: // purpose
+ this.purpose = castToString(value); // StringType
+ break;
+ case 111574433: // usage
+ this.usage = castToString(value); // StringType
+ break;
+ case 1470566394: // publicationDate
+ this.publicationDate = castToDate(value); // DateType
+ break;
+ case -1687512484: // lastReviewDate
+ this.lastReviewDate = castToDate(value); // DateType
+ break;
+ case -403934648: // effectivePeriod
+ this.effectivePeriod = castToPeriod(value); // Period
+ break;
+ case -351767064: // coverage
+ this.getCoverage().add(castToUsageContext(value)); // UsageContext
+ break;
+ case 110546223: // topic
+ this.getTopic().add(castToCodeableConcept(value)); // CodeableConcept
+ break;
+ case -1895276325: // contributor
+ this.getContributor().add(castToContributor(value)); // Contributor
+ break;
+ case 1447404028: // publisher
+ this.publisher = castToString(value); // StringType
+ break;
+ case 951526432: // contact
+ this.getContact().add(castToContactDetail(value)); // ContactDetail
+ break;
+ case 1522889671: // copyright
+ this.copyright = castToString(value); // StringType
+ break;
+ case 1554540889: // relatedResource
+ this.getRelatedResource().add(castToRelatedResource(value)); // RelatedResource
+ break;
+ case 166208699: // library
+ this.getLibrary().add(castToReference(value)); // Reference
+ break;
+ case 50511102: // category
+ this.category = new ActivityDefinitionCategoryEnumFactory().fromType(value); // Enumeration
+ break;
+ case 3059181: // code
+ this.code = castToCodeableConcept(value); // CodeableConcept
+ break;
+ case -873664438: // timing
+ this.timing = (Type) value; // Type
+ break;
+ case 1901043637: // location
+ this.location = castToReference(value); // Reference
+ break;
+ case 841294093: // participantType
+ this.getParticipantType().add(new ActivityParticipantTypeEnumFactory().fromType(value)); // Enumeration
+ break;
+ case -309474065: // product
+ this.product = (Type) value; // Type
+ break;
+ case -1285004149: // quantity
+ this.quantity = castToSimpleQuantity(value); // SimpleQuantity
+ break;
+ default: super.setProperty(hash, name, value);
+ }
+
+ }
+
+ @Override
+ public void setProperty(String name, Base value) throws FHIRException {
+ if (name.equals("url"))
+ this.url = castToUri(value); // UriType
+ else if (name.equals("identifier"))
+ this.getIdentifier().add(castToIdentifier(value));
+ else if (name.equals("version"))
+ this.version = castToString(value); // StringType
+ else if (name.equals("name"))
+ this.name = castToString(value); // StringType
+ else if (name.equals("title"))
+ this.title = castToString(value); // StringType
+ else if (name.equals("status"))
+ this.status = castToCode(value); // CodeType
+ else if (name.equals("experimental"))
+ this.experimental = castToBoolean(value); // BooleanType
+ else if (name.equals("description"))
+ this.description = castToString(value); // StringType
+ else if (name.equals("purpose"))
+ this.purpose = castToString(value); // StringType
+ else if (name.equals("usage"))
+ this.usage = castToString(value); // StringType
+ else if (name.equals("publicationDate"))
+ this.publicationDate = castToDate(value); // DateType
+ else if (name.equals("lastReviewDate"))
+ this.lastReviewDate = castToDate(value); // DateType
+ else if (name.equals("effectivePeriod"))
+ this.effectivePeriod = castToPeriod(value); // Period
+ else if (name.equals("coverage"))
+ this.getCoverage().add(castToUsageContext(value));
+ else if (name.equals("topic"))
+ this.getTopic().add(castToCodeableConcept(value));
+ else if (name.equals("contributor"))
+ this.getContributor().add(castToContributor(value));
+ else if (name.equals("publisher"))
+ this.publisher = castToString(value); // StringType
+ else if (name.equals("contact"))
+ this.getContact().add(castToContactDetail(value));
+ else if (name.equals("copyright"))
+ this.copyright = castToString(value); // StringType
+ else if (name.equals("relatedResource"))
+ this.getRelatedResource().add(castToRelatedResource(value));
+ else if (name.equals("library"))
+ this.getLibrary().add(castToReference(value));
+ else if (name.equals("category"))
+ this.category = new ActivityDefinitionCategoryEnumFactory().fromType(value); // Enumeration
+ else if (name.equals("code"))
+ this.code = castToCodeableConcept(value); // CodeableConcept
+ else if (name.equals("timing[x]"))
+ this.timing = (Type) value; // Type
+ else if (name.equals("location"))
+ this.location = castToReference(value); // Reference
+ else if (name.equals("participantType"))
+ this.getParticipantType().add(new ActivityParticipantTypeEnumFactory().fromType(value));
+ else if (name.equals("product[x]"))
+ this.product = (Type) value; // Type
+ else if (name.equals("quantity"))
+ this.quantity = castToSimpleQuantity(value); // SimpleQuantity
+ else
+ super.setProperty(name, value);
+ }
+
+ @Override
+ public Base makeProperty(int hash, String name) throws FHIRException {
+ switch (hash) {
+ case 116079: throw new FHIRException("Cannot make property url as it is not a complex type"); // UriType
+ case -1618432855: return addIdentifier(); // Identifier
+ case 351608024: throw new FHIRException("Cannot make property version as it is not a complex type"); // StringType
+ case 3373707: throw new FHIRException("Cannot make property name as it is not a complex type"); // StringType
+ case 110371416: throw new FHIRException("Cannot make property title as it is not a complex type"); // StringType
+ case -892481550: throw new FHIRException("Cannot make property status as it is not a complex type"); // CodeType
+ case -404562712: throw new FHIRException("Cannot make property experimental as it is not a complex type"); // BooleanType
+ case -1724546052: throw new FHIRException("Cannot make property description as it is not a complex type"); // StringType
+ case -220463842: throw new FHIRException("Cannot make property purpose as it is not a complex type"); // StringType
+ case 111574433: throw new FHIRException("Cannot make property usage as it is not a complex type"); // StringType
+ case 1470566394: throw new FHIRException("Cannot make property publicationDate as it is not a complex type"); // DateType
+ case -1687512484: throw new FHIRException("Cannot make property lastReviewDate as it is not a complex type"); // DateType
+ case -403934648: return getEffectivePeriod(); // Period
+ case -351767064: return addCoverage(); // UsageContext
+ case 110546223: return addTopic(); // CodeableConcept
+ case -1895276325: return addContributor(); // Contributor
+ case 1447404028: throw new FHIRException("Cannot make property publisher as it is not a complex type"); // StringType
+ case 951526432: return addContact(); // ContactDetail
+ case 1522889671: throw new FHIRException("Cannot make property copyright as it is not a complex type"); // StringType
+ case 1554540889: return addRelatedResource(); // RelatedResource
+ case 166208699: return addLibrary(); // Reference
+ case 50511102: throw new FHIRException("Cannot make property category as it is not a complex type"); // Enumeration
+ case 3059181: return getCode(); // CodeableConcept
+ case 164632566: return getTiming(); // Type
+ case 1901043637: return getLocation(); // Reference
+ case 841294093: throw new FHIRException("Cannot make property participantType as it is not a complex type"); // Enumeration
+ case 1753005361: return getProduct(); // Type
+ case -1285004149: return getQuantity(); // SimpleQuantity
+ default: return super.makeProperty(hash, name);
+ }
+
+ }
+
+ @Override
+ public Base addChild(String name) throws FHIRException {
+ if (name.equals("url")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.url");
+ }
+ else if (name.equals("identifier")) {
+ return addIdentifier();
+ }
+ else if (name.equals("version")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.version");
+ }
+ else if (name.equals("name")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.name");
+ }
+ else if (name.equals("title")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.title");
+ }
+ else if (name.equals("status")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.status");
+ }
+ else if (name.equals("experimental")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.experimental");
+ }
+ else if (name.equals("description")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.description");
+ }
+ else if (name.equals("purpose")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.purpose");
+ }
+ else if (name.equals("usage")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.usage");
+ }
+ else if (name.equals("publicationDate")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.publicationDate");
+ }
+ else if (name.equals("lastReviewDate")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.lastReviewDate");
+ }
+ else if (name.equals("effectivePeriod")) {
+ this.effectivePeriod = new Period();
+ return this.effectivePeriod;
+ }
+ else if (name.equals("coverage")) {
+ return addCoverage();
+ }
+ else if (name.equals("topic")) {
+ return addTopic();
+ }
+ else if (name.equals("contributor")) {
+ return addContributor();
+ }
+ else if (name.equals("publisher")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.publisher");
+ }
+ else if (name.equals("contact")) {
+ return addContact();
+ }
+ else if (name.equals("copyright")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.copyright");
+ }
+ else if (name.equals("relatedResource")) {
+ return addRelatedResource();
+ }
+ else if (name.equals("library")) {
+ return addLibrary();
+ }
+ else if (name.equals("category")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.category");
+ }
+ else if (name.equals("code")) {
+ this.code = new CodeableConcept();
+ return this.code;
+ }
+ else if (name.equals("timingCodeableConcept")) {
+ this.timing = new CodeableConcept();
+ return this.timing;
+ }
+ else if (name.equals("timingTiming")) {
+ this.timing = new Timing();
+ return this.timing;
+ }
+ else if (name.equals("location")) {
+ this.location = new Reference();
+ return this.location;
+ }
+ else if (name.equals("participantType")) {
+ throw new FHIRException("Cannot call addChild on a primitive type ActivityDefinition.participantType");
+ }
+ else if (name.equals("productReference")) {
+ this.product = new Reference();
+ return this.product;
+ }
+ else if (name.equals("productCodeableConcept")) {
+ this.product = new CodeableConcept();
+ return this.product;
+ }
+ else if (name.equals("quantity")) {
+ this.quantity = new SimpleQuantity();
+ return this.quantity;
+ }
+ else
+ return super.addChild(name);
+ }
+
+ public String fhirType() {
+ return "ActivityDefinition";
+
+ }
+
+ public ActivityDefinition copy() {
+ ActivityDefinition dst = new ActivityDefinition();
+ copyValues(dst);
+ dst.url = url == null ? null : url.copy();
+ if (identifier != null) {
+ dst.identifier = new ArrayList();
+ for (Identifier i : identifier)
+ dst.identifier.add(i.copy());
+ };
+ dst.version = version == null ? null : version.copy();
+ dst.name = name == null ? null : name.copy();
+ dst.title = title == null ? null : title.copy();
+ dst.status = status == null ? null : status.copy();
+ dst.experimental = experimental == null ? null : experimental.copy();
+ dst.description = description == null ? null : description.copy();
+ dst.purpose = purpose == null ? null : purpose.copy();
+ dst.usage = usage == null ? null : usage.copy();
+ dst.publicationDate = publicationDate == null ? null : publicationDate.copy();
+ dst.lastReviewDate = lastReviewDate == null ? null : lastReviewDate.copy();
+ dst.effectivePeriod = effectivePeriod == null ? null : effectivePeriod.copy();
+ if (coverage != null) {
+ dst.coverage = new ArrayList();
+ for (UsageContext i : coverage)
+ dst.coverage.add(i.copy());
+ };
+ if (topic != null) {
+ dst.topic = new ArrayList();
+ for (CodeableConcept i : topic)
+ dst.topic.add(i.copy());
+ };
+ if (contributor != null) {
+ dst.contributor = new ArrayList();
+ for (Contributor i : contributor)
+ dst.contributor.add(i.copy());
+ };
+ dst.publisher = publisher == null ? null : publisher.copy();
+ if (contact != null) {
+ dst.contact = new ArrayList();
+ for (ContactDetail i : contact)
+ dst.contact.add(i.copy());
+ };
+ dst.copyright = copyright == null ? null : copyright.copy();
+ if (relatedResource != null) {
+ dst.relatedResource = new ArrayList();
+ for (RelatedResource i : relatedResource)
+ dst.relatedResource.add(i.copy());
+ };
+ if (library != null) {
+ dst.library = new ArrayList();
+ for (Reference i : library)
+ dst.library.add(i.copy());
+ };
+ dst.category = category == null ? null : category.copy();
+ dst.code = code == null ? null : code.copy();
+ dst.timing = timing == null ? null : timing.copy();
+ dst.location = location == null ? null : location.copy();
+ if (participantType != null) {
+ dst.participantType = new ArrayList>();
+ for (Enumeration i : participantType)
+ dst.participantType.add(i.copy());
+ };
+ dst.product = product == null ? null : product.copy();
+ dst.quantity = quantity == null ? null : quantity.copy();
+ return dst;
+ }
+
+ protected ActivityDefinition typedCopy() {
+ return copy();
+ }
+
+ @Override
+ public boolean equalsDeep(Base other) {
+ if (!super.equalsDeep(other))
+ return false;
+ if (!(other instanceof ActivityDefinition))
+ return false;
+ ActivityDefinition o = (ActivityDefinition) other;
+ return compareDeep(url, o.url, true) && compareDeep(identifier, o.identifier, true) && compareDeep(version, o.version, true)
+ && compareDeep(name, o.name, true) && compareDeep(title, o.title, true) && compareDeep(status, o.status, true)
+ && compareDeep(experimental, o.experimental, true) && compareDeep(description, o.description, true)
+ && compareDeep(purpose, o.purpose, true) && compareDeep(usage, o.usage, true) && compareDeep(publicationDate, o.publicationDate, true)
+ && compareDeep(lastReviewDate, o.lastReviewDate, true) && compareDeep(effectivePeriod, o.effectivePeriod, true)
+ && compareDeep(coverage, o.coverage, true) && compareDeep(topic, o.topic, true) && compareDeep(contributor, o.contributor, true)
+ && compareDeep(publisher, o.publisher, true) && compareDeep(contact, o.contact, true) && compareDeep(copyright, o.copyright, true)
+ && compareDeep(relatedResource, o.relatedResource, true) && compareDeep(library, o.library, true)
+ && compareDeep(category, o.category, true) && compareDeep(code, o.code, true) && compareDeep(timing, o.timing, true)
+ && compareDeep(location, o.location, true) && compareDeep(participantType, o.participantType, true)
+ && compareDeep(product, o.product, true) && compareDeep(quantity, o.quantity, true);
+ }
+
+ @Override
+ public boolean equalsShallow(Base other) {
+ if (!super.equalsShallow(other))
+ return false;
+ if (!(other instanceof ActivityDefinition))
+ return false;
+ ActivityDefinition o = (ActivityDefinition) other;
+ return compareValues(url, o.url, true) && compareValues(version, o.version, true) && compareValues(name, o.name, true)
+ && compareValues(title, o.title, true) && compareValues(status, o.status, true) && compareValues(experimental, o.experimental, true)
+ && compareValues(description, o.description, true) && compareValues(purpose, o.purpose, true) && compareValues(usage, o.usage, true)
+ && compareValues(publicationDate, o.publicationDate, true) && compareValues(lastReviewDate, o.lastReviewDate, true)
+ && compareValues(publisher, o.publisher, true) && compareValues(copyright, o.copyright, true) && compareValues(category, o.category, true)
+ && compareValues(participantType, o.participantType, true);
+ }
+
+ public boolean isEmpty() {
+ return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(url, identifier, version
+ , name, title, status, experimental, description, purpose, usage, publicationDate
+ , lastReviewDate, effectivePeriod, coverage, topic, contributor, publisher, contact
+ , copyright, relatedResource, library, category, code, timing, location, participantType
+ , product, quantity);
+ }
+
+ @Override
+ public ResourceType getResourceType() {
+ return ResourceType.ActivityDefinition;
+ }
+
+ /**
+ * Search parameter: identifier
+ *
+ * Description: Logical identifier for the module (e.g. CMS-143)
+ * Type: token
+ * Path: ActivityDefinition.identifier
+ *
+ */
+ @SearchParamDefinition(name="identifier", path="ActivityDefinition.identifier", description="Logical identifier for the module (e.g. CMS-143)", type="token" )
+ public static final String SP_IDENTIFIER = "identifier";
+ /**
+ * Fluent Client search parameter constant for identifier
+ *
+ * Description: Logical identifier for the module (e.g. CMS-143)
+ * Type: token
+ * Path: ActivityDefinition.identifier
+ *
+ */
+ public static final ca.uhn.fhir.rest.gclient.TokenClientParam IDENTIFIER = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_IDENTIFIER);
+
+ /**
+ * Search parameter: topic
+ *
+ * Description: Topics associated with the module
+ * Type: token
+ * Path: ActivityDefinition.topic
+ *
+ */
+ @SearchParamDefinition(name="topic", path="ActivityDefinition.topic", description="Topics associated with the module", type="token" )
+ public static final String SP_TOPIC = "topic";
+ /**
+ * Fluent Client search parameter constant for topic
+ *
+ * Description: Topics associated with the module
+ * Type: token
+ * Path: ActivityDefinition.topic
+ *
+ */
+ public static final ca.uhn.fhir.rest.gclient.TokenClientParam TOPIC = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_TOPIC);
+
+ /**
+ * Search parameter: description
+ *
+ * Description: Text search against the description
+ * Type: string
+ * Path: ActivityDefinition.description
+ *
+ */
+ @SearchParamDefinition(name="description", path="ActivityDefinition.description", description="Text search against the description", type="string" )
+ public static final String SP_DESCRIPTION = "description";
+ /**
+ * Fluent Client search parameter constant for description
+ *
+ * Description: Text search against the description
+ * Type: string
+ * Path: ActivityDefinition.description
+ *
+ */
+ public static final ca.uhn.fhir.rest.gclient.StringClientParam DESCRIPTION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_DESCRIPTION);
+
+ /**
+ * Search parameter: title
+ *
+ * Description: Text search against the title
+ * Type: string
+ * Path: ActivityDefinition.title
+ *
+ */
+ @SearchParamDefinition(name="title", path="ActivityDefinition.title", description="Text search against the title", type="string" )
+ public static final String SP_TITLE = "title";
+ /**
+ * Fluent Client search parameter constant for title
+ *
+ * Description: Text search against the title
+ * Type: string
+ * Path: ActivityDefinition.title
+ *
+ */
+ public static final ca.uhn.fhir.rest.gclient.StringClientParam TITLE = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_TITLE);
+
+ /**
+ * Search parameter: version
+ *
+ * Description: Version of the module (e.g. 1.0.0)
+ * Type: string
+ * Path: ActivityDefinition.version
+ *
+ */
+ @SearchParamDefinition(name="version", path="ActivityDefinition.version", description="Version of the module (e.g. 1.0.0)", type="string" )
+ public static final String SP_VERSION = "version";
+ /**
+ * Fluent Client search parameter constant for version
+ *
+ * Description: Version of the module (e.g. 1.0.0)
+ * Type: string
+ * Path: ActivityDefinition.version
+ *
+ */
+ public static final ca.uhn.fhir.rest.gclient.StringClientParam VERSION = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_VERSION);
+
+ /**
+ * Search parameter: status
+ *
+ * Description: Status of the module
+ * Type: token
+ * Path: ActivityDefinition.status
+ *
+ */
+ @SearchParamDefinition(name="status", path="ActivityDefinition.status", description="Status of the module", type="token" )
+ public static final String SP_STATUS = "status";
+ /**
+ * Fluent Client search parameter constant for status
+ *
+ * Description: Status of the module
+ * Type: token
+ * Path: ActivityDefinition.status
+ *
+ */
+ public static final ca.uhn.fhir.rest.gclient.TokenClientParam STATUS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_STATUS);
+
+
+}
+
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Address.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Address.java
index ec9ab788a55..f419811caac 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Address.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Address.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sat, May 28, 2016 10:02-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -280,6 +280,7 @@ public class Address extends Type implements ICompositeType {
*/
@Child(name = "use", type = {CodeType.class}, order=0, min=0, max=1, modifier=true, summary=true)
@Description(shortDefinition="home | work | temp | old - purpose of this address", formalDefinition="The purpose of this address." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/address-use")
protected Enumeration use;
/**
@@ -287,6 +288,7 @@ public class Address extends Type implements ICompositeType {
*/
@Child(name = "type", type = {CodeType.class}, order=1, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="postal | physical | both", formalDefinition="Distinguishes between physical addresses (those you can visit) and mailing addresses (e.g. PO Boxes and care-of addresses). Most addresses are both." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/address-type")
protected Enumeration type;
/**
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Age.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Age.java
index 3aa119550a3..db153ca4d16 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Age.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Age.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sat, May 28, 2016 10:02-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AllergyIntolerance.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AllergyIntolerance.java
index c753256a576..6a06df9031e 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AllergyIntolerance.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AllergyIntolerance.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -755,6 +755,7 @@ public class AllergyIntolerance extends DomainResource {
*/
@Child(name = "substance", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="Specific substance considered to be responsible for event", formalDefinition="Identification of the specific substance considered to be responsible for the Adverse Reaction event. Note: the substance for a specific reaction may be different to the substance identified as the cause of the risk, but must be consistent with it. For instance, it may be a more specific substance (e.g. a brand medication) or a composite substance that includes the identified substance. It must be clinically safe to only process the AllergyIntolerance.substance and ignore the AllergyIntolerance.event.substance." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/substance-code")
protected CodeableConcept substance;
/**
@@ -762,6 +763,7 @@ public class AllergyIntolerance extends DomainResource {
*/
@Child(name = "certainty", type = {CodeType.class}, order=2, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="unlikely | likely | confirmed - clinical certainty about the specific substance", formalDefinition="Statement about the degree of clinical certainty that the specific substance was the cause of the manifestation in this reaction event." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/reaction-event-certainty")
protected Enumeration certainty;
/**
@@ -769,6 +771,7 @@ public class AllergyIntolerance extends DomainResource {
*/
@Child(name = "manifestation", type = {CodeableConcept.class}, order=3, min=1, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
@Description(shortDefinition="Clinical symptoms/signs associated with the Event", formalDefinition="Clinical symptoms and/or signs that are observed or associated with the adverse reaction event." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/manifestation-codes")
protected List manifestation;
/**
@@ -790,6 +793,7 @@ public class AllergyIntolerance extends DomainResource {
*/
@Child(name = "severity", type = {CodeType.class}, order=6, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="mild | moderate | severe (of event as a whole)", formalDefinition="Clinical assessment of the severity of the reaction event as a whole, potentially considering multiple different manifestations." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/reaction-event-severity")
protected Enumeration severity;
/**
@@ -797,6 +801,7 @@ public class AllergyIntolerance extends DomainResource {
*/
@Child(name = "exposureRoute", type = {CodeableConcept.class}, order=7, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="How the subject was exposed to the substance", formalDefinition="Identification of the route by which the subject was exposed to the substance." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/route-codes")
protected CodeableConcept exposureRoute;
/**
@@ -1364,6 +1369,7 @@ public class AllergyIntolerance extends DomainResource {
*/
@Child(name = "status", type = {CodeType.class}, order=1, min=0, max=1, modifier=true, summary=true)
@Description(shortDefinition="active | unconfirmed | confirmed | inactive | resolved | refuted | entered-in-error", formalDefinition="Assertion about certainty associated with the propensity, or potential risk, of a reaction to the identified Substance." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/allergy-intolerance-status")
protected Enumeration status;
/**
@@ -1371,6 +1377,7 @@ public class AllergyIntolerance extends DomainResource {
*/
@Child(name = "type", type = {CodeType.class}, order=2, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="allergy | intolerance - Underlying mechanism (if known)", formalDefinition="Identification of the underlying physiological mechanism for the reaction risk." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/allergy-intolerance-type")
protected Enumeration type;
/**
@@ -1378,6 +1385,7 @@ public class AllergyIntolerance extends DomainResource {
*/
@Child(name = "category", type = {CodeType.class}, order=3, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="food | medication | environment | other - Category of Substance", formalDefinition="Category of the identified Substance." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/allergy-intolerance-category")
protected Enumeration category;
/**
@@ -1385,6 +1393,7 @@ public class AllergyIntolerance extends DomainResource {
*/
@Child(name = "criticality", type = {CodeType.class}, order=4, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="low | high | unable-to-assess", formalDefinition="Estimate of the potential clinical harm, or seriousness, of the reaction to the identified Substance." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/allergy-intolerance-criticality")
protected Enumeration criticality;
/**
@@ -1392,6 +1401,7 @@ public class AllergyIntolerance extends DomainResource {
*/
@Child(name = "substance", type = {CodeableConcept.class}, order=5, min=1, max=1, modifier=false, summary=true)
@Description(shortDefinition="Substance, (or class) considered to be responsible for risk", formalDefinition="Identification of a substance, or a class of substances, that is considered to be responsible for the adverse reaction risk." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/allergyintolerance-substance-code")
protected CodeableConcept substance;
/**
@@ -2415,7 +2425,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.reaction.severity
*
*/
- @SearchParamDefinition(name="severity", path="AllergyIntolerance.reaction.severity", description="mild | moderate | severe (of event as a whole)", type="token", target={} )
+ @SearchParamDefinition(name="severity", path="AllergyIntolerance.reaction.severity", description="mild | moderate | severe (of event as a whole)", type="token" )
public static final String SP_SEVERITY = "severity";
/**
* Fluent Client search parameter constant for severity
@@ -2435,7 +2445,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.recordedDate
*
*/
- @SearchParamDefinition(name="date", path="AllergyIntolerance.recordedDate", description="When recorded", type="date", target={} )
+ @SearchParamDefinition(name="date", path="AllergyIntolerance.recordedDate", description="When recorded", type="date" )
public static final String SP_DATE = "date";
/**
* Fluent Client search parameter constant for date
@@ -2455,7 +2465,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.identifier
*
*/
- @SearchParamDefinition(name="identifier", path="AllergyIntolerance.identifier", description="External ids for this item", type="token", target={} )
+ @SearchParamDefinition(name="identifier", path="AllergyIntolerance.identifier", description="External ids for this item", type="token" )
public static final String SP_IDENTIFIER = "identifier";
/**
* Fluent Client search parameter constant for identifier
@@ -2475,7 +2485,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.reaction.manifestation
*
*/
- @SearchParamDefinition(name="manifestation", path="AllergyIntolerance.reaction.manifestation", description="Clinical symptoms/signs associated with the Event", type="token", target={} )
+ @SearchParamDefinition(name="manifestation", path="AllergyIntolerance.reaction.manifestation", description="Clinical symptoms/signs associated with the Event", type="token" )
public static final String SP_MANIFESTATION = "manifestation";
/**
* Fluent Client search parameter constant for manifestation
@@ -2495,7 +2505,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.recorder
*
*/
- @SearchParamDefinition(name="recorder", path="AllergyIntolerance.recorder", description="Who recorded the sensitivity", type="reference", target={Practitioner.class, Patient.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner") } )
+ @SearchParamDefinition(name="recorder", path="AllergyIntolerance.recorder", description="Who recorded the sensitivity", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner") } )
public static final String SP_RECORDER = "recorder";
/**
* Fluent Client search parameter constant for recorder
@@ -2521,7 +2531,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.substance, AllergyIntolerance.reaction.substance
*
*/
- @SearchParamDefinition(name="substance", path="AllergyIntolerance.substance | AllergyIntolerance.reaction.substance", description="Substance, (or class) considered to be responsible for risk", type="token", target={} )
+ @SearchParamDefinition(name="substance", path="AllergyIntolerance.substance | AllergyIntolerance.reaction.substance", description="Substance, (or class) considered to be responsible for risk", type="token" )
public static final String SP_SUBSTANCE = "substance";
/**
* Fluent Client search parameter constant for substance
@@ -2541,7 +2551,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.criticality
*
*/
- @SearchParamDefinition(name="criticality", path="AllergyIntolerance.criticality", description="low | high | unable-to-assess", type="token", target={} )
+ @SearchParamDefinition(name="criticality", path="AllergyIntolerance.criticality", description="low | high | unable-to-assess", type="token" )
public static final String SP_CRITICALITY = "criticality";
/**
* Fluent Client search parameter constant for criticality
@@ -2561,7 +2571,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.reporter
*
*/
- @SearchParamDefinition(name="reporter", path="AllergyIntolerance.reporter", description="Source of the information about the allergy", type="reference", target={Practitioner.class, Patient.class, RelatedPerson.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
+ @SearchParamDefinition(name="reporter", path="AllergyIntolerance.reporter", description="Source of the information about the allergy", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
public static final String SP_REPORTER = "reporter";
/**
* Fluent Client search parameter constant for reporter
@@ -2587,7 +2597,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.type
*
*/
- @SearchParamDefinition(name="type", path="AllergyIntolerance.type", description="allergy | intolerance - Underlying mechanism (if known)", type="token", target={} )
+ @SearchParamDefinition(name="type", path="AllergyIntolerance.type", description="allergy | intolerance - Underlying mechanism (if known)", type="token" )
public static final String SP_TYPE = "type";
/**
* Fluent Client search parameter constant for type
@@ -2607,7 +2617,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.reaction.onset
*
*/
- @SearchParamDefinition(name="onset", path="AllergyIntolerance.reaction.onset", description="Date(/time) when manifestations showed", type="date", target={} )
+ @SearchParamDefinition(name="onset", path="AllergyIntolerance.reaction.onset", description="Date(/time) when manifestations showed", type="date" )
public static final String SP_ONSET = "onset";
/**
* Fluent Client search parameter constant for onset
@@ -2627,7 +2637,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.reaction.exposureRoute
*
*/
- @SearchParamDefinition(name="route", path="AllergyIntolerance.reaction.exposureRoute", description="How the subject was exposed to the substance", type="token", target={} )
+ @SearchParamDefinition(name="route", path="AllergyIntolerance.reaction.exposureRoute", description="How the subject was exposed to the substance", type="token" )
public static final String SP_ROUTE = "route";
/**
* Fluent Client search parameter constant for route
@@ -2647,7 +2657,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.patient
*
*/
- @SearchParamDefinition(name="patient", path="AllergyIntolerance.patient", description="Who the sensitivity is for", type="reference", target={Patient.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
+ @SearchParamDefinition(name="patient", path="AllergyIntolerance.patient", description="Who the sensitivity is for", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
public static final String SP_PATIENT = "patient";
/**
* Fluent Client search parameter constant for patient
@@ -2673,7 +2683,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.category
*
*/
- @SearchParamDefinition(name="category", path="AllergyIntolerance.category", description="food | medication | environment | other - Category of Substance", type="token", target={} )
+ @SearchParamDefinition(name="category", path="AllergyIntolerance.category", description="food | medication | environment | other - Category of Substance", type="token" )
public static final String SP_CATEGORY = "category";
/**
* Fluent Client search parameter constant for category
@@ -2693,7 +2703,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.lastOccurence
*
*/
- @SearchParamDefinition(name="last-date", path="AllergyIntolerance.lastOccurence", description="Date(/time) of last known occurrence of a reaction", type="date", target={} )
+ @SearchParamDefinition(name="last-date", path="AllergyIntolerance.lastOccurence", description="Date(/time) of last known occurrence of a reaction", type="date" )
public static final String SP_LAST_DATE = "last-date";
/**
* Fluent Client search parameter constant for last-date
@@ -2713,7 +2723,7 @@ public class AllergyIntolerance extends DomainResource {
* Path: AllergyIntolerance.status
*
*/
- @SearchParamDefinition(name="status", path="AllergyIntolerance.status", description="active | unconfirmed | confirmed | inactive | resolved | refuted | entered-in-error", type="token", target={} )
+ @SearchParamDefinition(name="status", path="AllergyIntolerance.status", description="active | unconfirmed | confirmed | inactive | resolved | refuted | entered-in-error", type="token" )
public static final String SP_STATUS = "status";
/**
* Fluent Client search parameter constant for status
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Annotation.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Annotation.java
index b33d07f3c30..a096b142cc6 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Annotation.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Annotation.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sat, May 28, 2016 10:02-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Appointment.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Appointment.java
index f430a8bd516..c721e4a5395 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Appointment.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Appointment.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -453,6 +453,7 @@ public class Appointment extends DomainResource {
*/
@Child(name = "type", type = {CodeableConcept.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
@Description(shortDefinition="Role of participant in the appointment", formalDefinition="Role of participant in the appointment." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/encounter-participant-type")
protected List type;
/**
@@ -472,6 +473,7 @@ public class Appointment extends DomainResource {
*/
@Child(name = "required", type = {CodeType.class}, order=3, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="required | optional | information-only", formalDefinition="Is this participant required to be present at the meeting. This covers a use-case where 2 doctors need to meet to discuss the results for a specific patient, and the patient is not required to be present." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/participantrequired")
protected Enumeration required;
/**
@@ -479,6 +481,7 @@ public class Appointment extends DomainResource {
*/
@Child(name = "status", type = {CodeType.class}, order=4, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="accepted | declined | tentative | needs-action", formalDefinition="Participation status of the Patient." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/participationstatus")
protected Enumeration status;
private static final long serialVersionUID = -1620552507L;
@@ -828,6 +831,7 @@ public class Appointment extends DomainResource {
*/
@Child(name = "status", type = {CodeType.class}, order=1, min=1, max=1, modifier=true, summary=true)
@Description(shortDefinition="proposed | pending | booked | arrived | fulfilled | cancelled | noshow", formalDefinition="The overall status of the Appointment. Each of the participants has their own participation status which indicates their involvement in the process, however this status indicates the shared status." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/appointmentstatus")
protected Enumeration status;
/**
@@ -835,6 +839,7 @@ public class Appointment extends DomainResource {
*/
@Child(name = "serviceCategory", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="A broad categorisation of the service that is to be performed during this appointment", formalDefinition="A broad categorisation of the service that is to be performed during this appointment." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/service-category")
protected CodeableConcept serviceCategory;
/**
@@ -842,6 +847,7 @@ public class Appointment extends DomainResource {
*/
@Child(name = "serviceType", type = {CodeableConcept.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
@Description(shortDefinition="The specific service that is to be performed during this appointment", formalDefinition="The specific service that is to be performed during this appointment." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/service-type")
protected List serviceType;
/**
@@ -849,6 +855,7 @@ public class Appointment extends DomainResource {
*/
@Child(name = "specialty", type = {CodeableConcept.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
@Description(shortDefinition="The specialty of a practitioner that would be required to perform the service requested in this appointment", formalDefinition="The specialty of a practitioner that would be required to perform the service requested in this appointment." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/c80-practice-codes")
protected List specialty;
/**
@@ -856,6 +863,7 @@ public class Appointment extends DomainResource {
*/
@Child(name = "appointmentType", type = {CodeableConcept.class}, order=5, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="The style of appointment or patient that has been booked in the slot (not service type)", formalDefinition="The style of appointment or patient that has been booked in the slot (not service type)." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/v2-0276")
protected CodeableConcept appointmentType;
/**
@@ -863,6 +871,7 @@ public class Appointment extends DomainResource {
*/
@Child(name = "reason", type = {CodeableConcept.class}, order=6, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="Reason this appointment is scheduled", formalDefinition="The reason that this appointment is being scheduled. This is more clinical than administrative." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/encounter-reason")
protected CodeableConcept reason;
/**
@@ -2005,7 +2014,7 @@ public class Appointment extends DomainResource {
* Path: Appointment.start
*
*/
- @SearchParamDefinition(name="date", path="Appointment.start", description="Appointment date/time.", type="date", target={} )
+ @SearchParamDefinition(name="date", path="Appointment.start", description="Appointment date/time.", type="date" )
public static final String SP_DATE = "date";
/**
* Fluent Client search parameter constant for date
@@ -2025,7 +2034,7 @@ public class Appointment extends DomainResource {
* Path: Appointment.participant.actor
*
*/
- @SearchParamDefinition(name="actor", path="Appointment.participant.actor", description="Any one of the individuals participating in the appointment", type="reference", target={Practitioner.class, Device.class, Patient.class, HealthcareService.class, RelatedPerson.class, Location.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
+ @SearchParamDefinition(name="actor", path="Appointment.participant.actor", description="Any one of the individuals participating in the appointment", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
public static final String SP_ACTOR = "actor";
/**
* Fluent Client search parameter constant for actor
@@ -2051,7 +2060,7 @@ public class Appointment extends DomainResource {
* Path: Appointment.identifier
*
*/
- @SearchParamDefinition(name="identifier", path="Appointment.identifier", description="An Identifier of the Appointment", type="token", target={} )
+ @SearchParamDefinition(name="identifier", path="Appointment.identifier", description="An Identifier of the Appointment", type="token" )
public static final String SP_IDENTIFIER = "identifier";
/**
* Fluent Client search parameter constant for identifier
@@ -2071,7 +2080,7 @@ public class Appointment extends DomainResource {
* Path: Appointment.participant.actor
*
*/
- @SearchParamDefinition(name="practitioner", path="Appointment.participant.actor", description="One of the individuals of the appointment is this practitioner", type="reference", target={Practitioner.class} )
+ @SearchParamDefinition(name="practitioner", path="Appointment.participant.actor", description="One of the individuals of the appointment is this practitioner", type="reference" )
public static final String SP_PRACTITIONER = "practitioner";
/**
* Fluent Client search parameter constant for practitioner
@@ -2097,7 +2106,7 @@ public class Appointment extends DomainResource {
* Path: Appointment.participant.status
*
*/
- @SearchParamDefinition(name="part-status", path="Appointment.participant.status", description="The Participation status of the subject, or other participant on the appointment. Can be used to locate participants that have not responded to meeting requests.", type="token", target={} )
+ @SearchParamDefinition(name="part-status", path="Appointment.participant.status", description="The Participation status of the subject, or other participant on the appointment. Can be used to locate participants that have not responded to meeting requests.", type="token" )
public static final String SP_PART_STATUS = "part-status";
/**
* Fluent Client search parameter constant for part-status
@@ -2117,7 +2126,7 @@ public class Appointment extends DomainResource {
* Path: Appointment.participant.actor
*
*/
- @SearchParamDefinition(name="patient", path="Appointment.participant.actor", description="One of the individuals of the appointment is this patient", type="reference", target={Patient.class} )
+ @SearchParamDefinition(name="patient", path="Appointment.participant.actor", description="One of the individuals of the appointment is this patient", type="reference" )
public static final String SP_PATIENT = "patient";
/**
* Fluent Client search parameter constant for patient
@@ -2143,7 +2152,7 @@ public class Appointment extends DomainResource {
* Path: Appointment.appointmentType
*
*/
- @SearchParamDefinition(name="appointment-type", path="Appointment.appointmentType", description="The style of appointment or patient that has been booked in the slot (not service type)", type="token", target={} )
+ @SearchParamDefinition(name="appointment-type", path="Appointment.appointmentType", description="The style of appointment or patient that has been booked in the slot (not service type)", type="token" )
public static final String SP_APPOINTMENT_TYPE = "appointment-type";
/**
* Fluent Client search parameter constant for appointment-type
@@ -2163,7 +2172,7 @@ public class Appointment extends DomainResource {
* Path: Appointment.serviceType
*
*/
- @SearchParamDefinition(name="service-type", path="Appointment.serviceType", description="The specific service that is to be performed during this appointment", type="token", target={} )
+ @SearchParamDefinition(name="service-type", path="Appointment.serviceType", description="The specific service that is to be performed during this appointment", type="token" )
public static final String SP_SERVICE_TYPE = "service-type";
/**
* Fluent Client search parameter constant for service-type
@@ -2183,7 +2192,7 @@ public class Appointment extends DomainResource {
* Path: Appointment.participant.actor
*
*/
- @SearchParamDefinition(name="location", path="Appointment.participant.actor", description="This location is listed in the participants of the appointment", type="reference", target={Location.class} )
+ @SearchParamDefinition(name="location", path="Appointment.participant.actor", description="This location is listed in the participants of the appointment", type="reference" )
public static final String SP_LOCATION = "location";
/**
* Fluent Client search parameter constant for location
@@ -2209,7 +2218,7 @@ public class Appointment extends DomainResource {
* Path: Appointment.status
*
*/
- @SearchParamDefinition(name="status", path="Appointment.status", description="The overall status of the appointment", type="token", target={} )
+ @SearchParamDefinition(name="status", path="Appointment.status", description="The overall status of the appointment", type="token" )
public static final String SP_STATUS = "status";
/**
* Fluent Client search parameter constant for status
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AppointmentResponse.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AppointmentResponse.java
index 16f4d31d321..0b06be11d1e 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AppointmentResponse.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AppointmentResponse.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -86,6 +86,7 @@ public class AppointmentResponse extends DomainResource {
*/
@Child(name = "participantType", type = {CodeableConcept.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
@Description(shortDefinition="Role of participant in the appointment", formalDefinition="Role of participant in the appointment." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/encounter-participant-type")
protected List participantType;
/**
@@ -105,6 +106,7 @@ public class AppointmentResponse extends DomainResource {
*/
@Child(name = "participantStatus", type = {CodeType.class}, order=6, min=1, max=1, modifier=true, summary=true)
@Description(shortDefinition="accepted | declined | tentative | in-process | completed | needs-action", formalDefinition="Participation status of the participant. When the status is declined or tentative if the start/end times are different to the appointment, then these times should be interpreted as a requested time change. When the status is accepted, the times can either be the time of the appointment (as a confirmation of the time) or can be empty." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/participationstatus")
protected CodeType participantStatus;
/**
@@ -716,7 +718,7 @@ public class AppointmentResponse extends DomainResource {
* Path: AppointmentResponse.actor
*
*/
- @SearchParamDefinition(name="actor", path="AppointmentResponse.actor", description="The Person, Location/HealthcareService or Device that this appointment response replies for", type="reference", target={Practitioner.class, Device.class, Patient.class, HealthcareService.class, RelatedPerson.class, Location.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
+ @SearchParamDefinition(name="actor", path="AppointmentResponse.actor", description="The Person, Location/HealthcareService or Device that this appointment response replies for", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
public static final String SP_ACTOR = "actor";
/**
* Fluent Client search parameter constant for actor
@@ -742,7 +744,7 @@ public class AppointmentResponse extends DomainResource {
* Path: AppointmentResponse.identifier
*
*/
- @SearchParamDefinition(name="identifier", path="AppointmentResponse.identifier", description="An Identifier in this appointment response", type="token", target={} )
+ @SearchParamDefinition(name="identifier", path="AppointmentResponse.identifier", description="An Identifier in this appointment response", type="token" )
public static final String SP_IDENTIFIER = "identifier";
/**
* Fluent Client search parameter constant for identifier
@@ -762,7 +764,7 @@ public class AppointmentResponse extends DomainResource {
* Path: AppointmentResponse.actor
*
*/
- @SearchParamDefinition(name="practitioner", path="AppointmentResponse.actor", description="This Response is for this Practitioner", type="reference", target={Practitioner.class} )
+ @SearchParamDefinition(name="practitioner", path="AppointmentResponse.actor", description="This Response is for this Practitioner", type="reference" )
public static final String SP_PRACTITIONER = "practitioner";
/**
* Fluent Client search parameter constant for practitioner
@@ -788,7 +790,7 @@ public class AppointmentResponse extends DomainResource {
* Path: AppointmentResponse.participantStatus
*
*/
- @SearchParamDefinition(name="part-status", path="AppointmentResponse.participantStatus", description="The participants acceptance status for this appointment", type="token", target={} )
+ @SearchParamDefinition(name="part-status", path="AppointmentResponse.participantStatus", description="The participants acceptance status for this appointment", type="token" )
public static final String SP_PART_STATUS = "part-status";
/**
* Fluent Client search parameter constant for part-status
@@ -808,7 +810,7 @@ public class AppointmentResponse extends DomainResource {
* Path: AppointmentResponse.actor
*
*/
- @SearchParamDefinition(name="patient", path="AppointmentResponse.actor", description="This Response is for this Patient", type="reference", target={Patient.class} )
+ @SearchParamDefinition(name="patient", path="AppointmentResponse.actor", description="This Response is for this Patient", type="reference" )
public static final String SP_PATIENT = "patient";
/**
* Fluent Client search parameter constant for patient
@@ -834,7 +836,7 @@ public class AppointmentResponse extends DomainResource {
* Path: AppointmentResponse.appointment
*
*/
- @SearchParamDefinition(name="appointment", path="AppointmentResponse.appointment", description="The appointment that the response is attached to", type="reference", target={Appointment.class} )
+ @SearchParamDefinition(name="appointment", path="AppointmentResponse.appointment", description="The appointment that the response is attached to", type="reference" )
public static final String SP_APPOINTMENT = "appointment";
/**
* Fluent Client search parameter constant for appointment
@@ -860,7 +862,7 @@ public class AppointmentResponse extends DomainResource {
* Path: AppointmentResponse.actor
*
*/
- @SearchParamDefinition(name="location", path="AppointmentResponse.actor", description="This Response is for this Location", type="reference", target={Location.class} )
+ @SearchParamDefinition(name="location", path="AppointmentResponse.actor", description="This Response is for this Location", type="reference" )
public static final String SP_LOCATION = "location";
/**
* Fluent Client search parameter constant for location
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Attachment.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Attachment.java
index b137f4afa79..6e49c5136cb 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Attachment.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Attachment.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sat, May 28, 2016 10:02-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AuditEvent.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AuditEvent.java
index 74614e1c01b..defb2e7b001 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AuditEvent.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/AuditEvent.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -309,7 +309,7 @@ public class AuditEvent extends DomainResource {
}
}
- public enum AuditEventParticipantNetworkType {
+ public enum AuditEventAgentNetworkType {
/**
* The machine name, including DNS name.
*/
@@ -334,7 +334,7 @@ public class AuditEvent extends DomainResource {
* added to help the parsers with the generic types
*/
NULL;
- public static AuditEventParticipantNetworkType fromCode(String codeString) throws FHIRException {
+ public static AuditEventAgentNetworkType fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("1".equals(codeString))
@@ -350,7 +350,7 @@ public class AuditEvent extends DomainResource {
if (Configuration.isAcceptInvalidEnums())
return null;
else
- throw new FHIRException("Unknown AuditEventParticipantNetworkType code '"+codeString+"'");
+ throw new FHIRException("Unknown AuditEventAgentNetworkType code '"+codeString+"'");
}
public String toCode() {
switch (this) {
@@ -394,55 +394,55 @@ public class AuditEvent extends DomainResource {
}
}
- public static class AuditEventParticipantNetworkTypeEnumFactory implements EnumFactory {
- public AuditEventParticipantNetworkType fromCode(String codeString) throws IllegalArgumentException {
+ public static class AuditEventAgentNetworkTypeEnumFactory implements EnumFactory {
+ public AuditEventAgentNetworkType fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("1".equals(codeString))
- return AuditEventParticipantNetworkType._1;
+ return AuditEventAgentNetworkType._1;
if ("2".equals(codeString))
- return AuditEventParticipantNetworkType._2;
+ return AuditEventAgentNetworkType._2;
if ("3".equals(codeString))
- return AuditEventParticipantNetworkType._3;
+ return AuditEventAgentNetworkType._3;
if ("4".equals(codeString))
- return AuditEventParticipantNetworkType._4;
+ return AuditEventAgentNetworkType._4;
if ("5".equals(codeString))
- return AuditEventParticipantNetworkType._5;
- throw new IllegalArgumentException("Unknown AuditEventParticipantNetworkType code '"+codeString+"'");
+ return AuditEventAgentNetworkType._5;
+ throw new IllegalArgumentException("Unknown AuditEventAgentNetworkType code '"+codeString+"'");
}
- public Enumeration fromType(Base code) throws FHIRException {
+ public Enumeration fromType(Base code) throws FHIRException {
if (code == null || code.isEmpty())
return null;
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return null;
if ("1".equals(codeString))
- return new Enumeration(this, AuditEventParticipantNetworkType._1);
+ return new Enumeration(this, AuditEventAgentNetworkType._1);
if ("2".equals(codeString))
- return new Enumeration(this, AuditEventParticipantNetworkType._2);
+ return new Enumeration(this, AuditEventAgentNetworkType._2);
if ("3".equals(codeString))
- return new Enumeration(this, AuditEventParticipantNetworkType._3);
+ return new Enumeration(this, AuditEventAgentNetworkType._3);
if ("4".equals(codeString))
- return new Enumeration(this, AuditEventParticipantNetworkType._4);
+ return new Enumeration(this, AuditEventAgentNetworkType._4);
if ("5".equals(codeString))
- return new Enumeration(this, AuditEventParticipantNetworkType._5);
- throw new FHIRException("Unknown AuditEventParticipantNetworkType code '"+codeString+"'");
+ return new Enumeration(this, AuditEventAgentNetworkType._5);
+ throw new FHIRException("Unknown AuditEventAgentNetworkType code '"+codeString+"'");
}
- public String toCode(AuditEventParticipantNetworkType code) {
- if (code == AuditEventParticipantNetworkType._1)
+ public String toCode(AuditEventAgentNetworkType code) {
+ if (code == AuditEventAgentNetworkType._1)
return "1";
- if (code == AuditEventParticipantNetworkType._2)
+ if (code == AuditEventAgentNetworkType._2)
return "2";
- if (code == AuditEventParticipantNetworkType._3)
+ if (code == AuditEventAgentNetworkType._3)
return "3";
- if (code == AuditEventParticipantNetworkType._4)
+ if (code == AuditEventAgentNetworkType._4)
return "4";
- if (code == AuditEventParticipantNetworkType._5)
+ if (code == AuditEventAgentNetworkType._5)
return "5";
return "?";
}
- public String toSystem(AuditEventParticipantNetworkType code) {
+ public String toSystem(AuditEventAgentNetworkType code) {
return code.getSystem();
}
}
@@ -450,10 +450,11 @@ public class AuditEvent extends DomainResource {
@Block()
public static class AuditEventAgentComponent extends BackboneElement implements IBaseBackboneElement {
/**
- * Specification of the role(s) the user plays when performing the event. Usually the codes used in this element are local codes defined by the access control security system (e.g. RBAC, ABAC) used in the local context.
+ * Specification of the role(s) the user plays when performing the event. Additional may contain security role codes that come from local codes defined by the access control security system (e.g. RBAC, ABAC) used in the local context.
*/
@Child(name = "role", type = {CodeableConcept.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
- @Description(shortDefinition="Agent role in the event", formalDefinition="Specification of the role(s) the user plays when performing the event. Usually the codes used in this element are local codes defined by the access control security system (e.g. RBAC, ABAC) used in the local context." )
+ @Description(shortDefinition="Agent role in the event", formalDefinition="Specification of the role(s) the user plays when performing the event. Additional may contain security role codes that come from local codes defined by the access control security system (e.g. RBAC, ABAC) used in the local context." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/dicm-402-roleid")
protected List role;
/**
@@ -520,6 +521,7 @@ public class AuditEvent extends DomainResource {
*/
@Child(name = "media", type = {Coding.class}, order=9, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Type of media", formalDefinition="Type of media involved. Used when the event is about exporting/importing onto media." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/dicm-405-mediatype")
protected Coding media;
/**
@@ -534,6 +536,7 @@ public class AuditEvent extends DomainResource {
*/
@Child(name = "purposeOfUse", type = {Coding.class}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Reason given for this user", formalDefinition="The reason (purpose of use), specific to this agent, that was used during the event being recorded." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/v3-PurposeOfUse")
protected List purposeOfUse;
private static final long serialVersionUID = 1802747339L;
@@ -554,7 +557,7 @@ public class AuditEvent extends DomainResource {
}
/**
- * @return {@link #role} (Specification of the role(s) the user plays when performing the event. Usually the codes used in this element are local codes defined by the access control security system (e.g. RBAC, ABAC) used in the local context.)
+ * @return {@link #role} (Specification of the role(s) the user plays when performing the event. Additional may contain security role codes that come from local codes defined by the access control security system (e.g. RBAC, ABAC) used in the local context.)
*/
public List getRole() {
if (this.role == null)
@@ -1020,7 +1023,7 @@ public class AuditEvent extends DomainResource {
protected void listChildren(List childrenList) {
super.listChildren(childrenList);
- childrenList.add(new Property("role", "CodeableConcept", "Specification of the role(s) the user plays when performing the event. Usually the codes used in this element are local codes defined by the access control security system (e.g. RBAC, ABAC) used in the local context.", 0, java.lang.Integer.MAX_VALUE, role));
+ childrenList.add(new Property("role", "CodeableConcept", "Specification of the role(s) the user plays when performing the event. Additional may contain security role codes that come from local codes defined by the access control security system (e.g. RBAC, ABAC) used in the local context.", 0, java.lang.Integer.MAX_VALUE, role));
childrenList.add(new Property("reference", "Reference(Practitioner|Organization|Device|Patient|RelatedPerson)", "Direct reference to a resource that identifies the agent.", 0, java.lang.Integer.MAX_VALUE, reference));
childrenList.add(new Property("userId", "Identifier", "Unique identifier for the user actively participating in the event.", 0, java.lang.Integer.MAX_VALUE, userId));
childrenList.add(new Property("altId", "string", "Alternative agent Identifier. For a human, this should be a user identifier text string from authentication system. This identifier would be one known to a common authentication system (e.g. single sign-on), if available.", 0, java.lang.Integer.MAX_VALUE, altId));
@@ -1263,9 +1266,10 @@ public class AuditEvent extends DomainResource {
*/
@Child(name = "type", type = {CodeType.class}, order=2, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="The type of network access point", formalDefinition="An identifier for the type of network access point that originated the audit event." )
- protected Enumeration type;
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/network-type")
+ protected Enumeration type;
- private static final long serialVersionUID = -1355220390L;
+ private static final long serialVersionUID = -160715924L;
/**
* Constructor
@@ -1326,12 +1330,12 @@ public class AuditEvent extends DomainResource {
/**
* @return {@link #type} (An identifier for the type of network access point that originated the audit event.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
*/
- public Enumeration getTypeElement() {
+ public Enumeration getTypeElement() {
if (this.type == null)
if (Configuration.errorOnAutoCreate())
throw new Error("Attempt to auto-create AuditEventAgentNetworkComponent.type");
else if (Configuration.doAutoCreate())
- this.type = new Enumeration(new AuditEventParticipantNetworkTypeEnumFactory()); // bb
+ this.type = new Enumeration(new AuditEventAgentNetworkTypeEnumFactory()); // bb
return this.type;
}
@@ -1346,7 +1350,7 @@ public class AuditEvent extends DomainResource {
/**
* @param value {@link #type} (An identifier for the type of network access point that originated the audit event.). This is the underlying object with id, value and extensions. The accessor "getType" gives direct access to the value
*/
- public AuditEventAgentNetworkComponent setTypeElement(Enumeration value) {
+ public AuditEventAgentNetworkComponent setTypeElement(Enumeration value) {
this.type = value;
return this;
}
@@ -1354,19 +1358,19 @@ public class AuditEvent extends DomainResource {
/**
* @return An identifier for the type of network access point that originated the audit event.
*/
- public AuditEventParticipantNetworkType getType() {
+ public AuditEventAgentNetworkType getType() {
return this.type == null ? null : this.type.getValue();
}
/**
* @param value An identifier for the type of network access point that originated the audit event.
*/
- public AuditEventAgentNetworkComponent setType(AuditEventParticipantNetworkType value) {
+ public AuditEventAgentNetworkComponent setType(AuditEventAgentNetworkType value) {
if (value == null)
this.type = null;
else {
if (this.type == null)
- this.type = new Enumeration(new AuditEventParticipantNetworkTypeEnumFactory());
+ this.type = new Enumeration(new AuditEventAgentNetworkTypeEnumFactory());
this.type.setValue(value);
}
return this;
@@ -1382,7 +1386,7 @@ public class AuditEvent extends DomainResource {
public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
switch (hash) {
case -1147692044: /*address*/ return this.address == null ? new Base[0] : new Base[] {this.address}; // StringType
- case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration
+ case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Enumeration
default: return super.getProperty(hash, name, checkValid);
}
@@ -1395,7 +1399,7 @@ public class AuditEvent extends DomainResource {
this.address = castToString(value); // StringType
break;
case 3575610: // type
- this.type = new AuditEventParticipantNetworkTypeEnumFactory().fromType(value); // Enumeration
+ this.type = new AuditEventAgentNetworkTypeEnumFactory().fromType(value); // Enumeration
break;
default: super.setProperty(hash, name, value);
}
@@ -1407,7 +1411,7 @@ public class AuditEvent extends DomainResource {
if (name.equals("address"))
this.address = castToString(value); // StringType
else if (name.equals("type"))
- this.type = new AuditEventParticipantNetworkTypeEnumFactory().fromType(value); // Enumeration
+ this.type = new AuditEventAgentNetworkTypeEnumFactory().fromType(value); // Enumeration
else
super.setProperty(name, value);
}
@@ -1416,7 +1420,7 @@ public class AuditEvent extends DomainResource {
public Base makeProperty(int hash, String name) throws FHIRException {
switch (hash) {
case -1147692044: throw new FHIRException("Cannot make property address as it is not a complex type"); // StringType
- case 3575610: throw new FHIRException("Cannot make property type as it is not a complex type"); // Enumeration
+ case 3575610: throw new FHIRException("Cannot make property type as it is not a complex type"); // Enumeration
default: return super.makeProperty(hash, name);
}
@@ -1494,6 +1498,7 @@ public class AuditEvent extends DomainResource {
*/
@Child(name = "type", type = {Coding.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="The type of source where event originated", formalDefinition="Code specifying the type of source where event originated." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/audit-source-type")
protected List type;
private static final long serialVersionUID = -1562673890L;
@@ -1764,18 +1769,18 @@ public class AuditEvent extends DomainResource {
* Identifies a specific instance of the entity. The reference should always be version specific.
*/
@Child(name = "identifier", type = {Identifier.class}, order=1, min=0, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Specific instance of object (e.g. versioned)", formalDefinition="Identifies a specific instance of the entity. The reference should always be version specific." )
+ @Description(shortDefinition="Specific instance of object", formalDefinition="Identifies a specific instance of the entity. The reference should always be version specific." )
protected Identifier identifier;
/**
- * Identifies a specific instance of the entity. The reference should always be version specific.
+ * Identifies a specific instance of the entity. The reference should be version specific.
*/
@Child(name = "reference", type = {}, order=2, min=0, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Specific instance of resource (e.g. versioned)", formalDefinition="Identifies a specific instance of the entity. The reference should always be version specific." )
+ @Description(shortDefinition="Specific instance of resource", formalDefinition="Identifies a specific instance of the entity. The reference should be version specific." )
protected Reference reference;
/**
- * The actual object that is the target of the reference (Identifies a specific instance of the entity. The reference should always be version specific.)
+ * The actual object that is the target of the reference (Identifies a specific instance of the entity. The reference should be version specific.)
*/
protected Resource referenceTarget;
@@ -1783,7 +1788,8 @@ public class AuditEvent extends DomainResource {
* The type of the object that was involved in this audit event.
*/
@Child(name = "type", type = {Coding.class}, order=3, min=0, max=1, modifier=false, summary=false)
- @Description(shortDefinition="Type of object involved", formalDefinition="The type of the object that was involved in this audit event." )
+ @Description(shortDefinition="Type of entity involved", formalDefinition="The type of the object that was involved in this audit event." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/object-type")
protected Coding type;
/**
@@ -1791,20 +1797,23 @@ public class AuditEvent extends DomainResource {
*/
@Child(name = "role", type = {Coding.class}, order=4, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="What role the entity played", formalDefinition="Code representing the role the entity played in the event being audited." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/object-role")
protected Coding role;
/**
* Identifier for the data life-cycle stage for the entity.
*/
@Child(name = "lifecycle", type = {Coding.class}, order=5, min=0, max=1, modifier=false, summary=false)
- @Description(shortDefinition="Life-cycle stage for the object", formalDefinition="Identifier for the data life-cycle stage for the entity." )
+ @Description(shortDefinition="Life-cycle stage for the entity", formalDefinition="Identifier for the data life-cycle stage for the entity." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/object-lifecycle")
protected Coding lifecycle;
/**
* Denotes security labels for the identified entity.
*/
@Child(name = "securityLabel", type = {Coding.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
- @Description(shortDefinition="Security labels applied to the object", formalDefinition="Denotes security labels for the identified entity." )
+ @Description(shortDefinition="Security labels on the entity", formalDefinition="Denotes security labels for the identified entity." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/security-labels")
protected List securityLabel;
/**
@@ -1869,7 +1878,7 @@ public class AuditEvent extends DomainResource {
}
/**
- * @return {@link #reference} (Identifies a specific instance of the entity. The reference should always be version specific.)
+ * @return {@link #reference} (Identifies a specific instance of the entity. The reference should be version specific.)
*/
public Reference getReference() {
if (this.reference == null)
@@ -1885,7 +1894,7 @@ public class AuditEvent extends DomainResource {
}
/**
- * @param value {@link #reference} (Identifies a specific instance of the entity. The reference should always be version specific.)
+ * @param value {@link #reference} (Identifies a specific instance of the entity. The reference should be version specific.)
*/
public AuditEventEntityComponent setReference(Reference value) {
this.reference = value;
@@ -1893,14 +1902,14 @@ public class AuditEvent extends DomainResource {
}
/**
- * @return {@link #reference} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Identifies a specific instance of the entity. The reference should always be version specific.)
+ * @return {@link #reference} The actual object that is the target of the reference. The reference library doesn't populate this, but you can use it to hold the resource if you resolve it. (Identifies a specific instance of the entity. The reference should be version specific.)
*/
public Resource getReferenceTarget() {
return this.referenceTarget;
}
/**
- * @param value {@link #reference} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Identifies a specific instance of the entity. The reference should always be version specific.)
+ * @param value {@link #reference} The actual object that is the target of the reference. The reference library doesn't use these, but you can use it to hold the resource if you resolve it. (Identifies a specific instance of the entity. The reference should be version specific.)
*/
public AuditEventEntityComponent setReferenceTarget(Resource value) {
this.referenceTarget = value;
@@ -2235,7 +2244,7 @@ public class AuditEvent extends DomainResource {
protected void listChildren(List childrenList) {
super.listChildren(childrenList);
childrenList.add(new Property("identifier", "Identifier", "Identifies a specific instance of the entity. The reference should always be version specific.", 0, java.lang.Integer.MAX_VALUE, identifier));
- childrenList.add(new Property("reference", "Reference(Any)", "Identifies a specific instance of the entity. The reference should always be version specific.", 0, java.lang.Integer.MAX_VALUE, reference));
+ childrenList.add(new Property("reference", "Reference(Any)", "Identifies a specific instance of the entity. The reference should be version specific.", 0, java.lang.Integer.MAX_VALUE, reference));
childrenList.add(new Property("type", "Coding", "The type of the object that was involved in this audit event.", 0, java.lang.Integer.MAX_VALUE, type));
childrenList.add(new Property("role", "Coding", "Code representing the role the entity played in the event being audited.", 0, java.lang.Integer.MAX_VALUE, role));
childrenList.add(new Property("lifecycle", "Coding", "Identifier for the data life-cycle stage for the entity.", 0, java.lang.Integer.MAX_VALUE, lifecycle));
@@ -2677,6 +2686,7 @@ public class AuditEvent extends DomainResource {
*/
@Child(name = "type", type = {Coding.class}, order=0, min=1, max=1, modifier=false, summary=true)
@Description(shortDefinition="Type/identifier of event", formalDefinition="Identifier for a family of the event. For example, a menu item, program, rule, policy, function code, application name or URL. It identifies the performed function." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/audit-event-type")
protected Coding type;
/**
@@ -2684,6 +2694,7 @@ public class AuditEvent extends DomainResource {
*/
@Child(name = "subtype", type = {Coding.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
@Description(shortDefinition="More specific type/id for the event", formalDefinition="Identifier for the category of event." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/audit-event-sub-type")
protected List subtype;
/**
@@ -2691,6 +2702,7 @@ public class AuditEvent extends DomainResource {
*/
@Child(name = "action", type = {CodeType.class}, order=2, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="Type of action performed during the event", formalDefinition="Indicator for type of action performed during the event that generated the audit." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/audit-event-action")
protected Enumeration action;
/**
@@ -2705,6 +2717,7 @@ public class AuditEvent extends DomainResource {
*/
@Child(name = "outcome", type = {CodeType.class}, order=4, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="Whether the event succeeded or failed", formalDefinition="Indicates whether the event succeeded or failed." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/audit-event-outcome")
protected Enumeration outcome;
/**
@@ -2719,6 +2732,7 @@ public class AuditEvent extends DomainResource {
*/
@Child(name = "purposeOfEvent", type = {Coding.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
@Description(shortDefinition="The purposeOfUse of the event", formalDefinition="The purposeOfUse (reason) that was used during the event being recorded." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/v3-PurposeOfUse")
protected List purposeOfEvent;
/**
@@ -2729,17 +2743,17 @@ public class AuditEvent extends DomainResource {
protected List agent;
/**
- * Application systems and processes.
+ * The system that is reporting the event.
*/
@Child(name = "source", type = {}, order=8, min=1, max=1, modifier=false, summary=false)
- @Description(shortDefinition="Application systems and processes", formalDefinition="Application systems and processes." )
+ @Description(shortDefinition="Audit Event Reporter", formalDefinition="The system that is reporting the event." )
protected AuditEventSourceComponent source;
/**
* Specific instances of data or objects that have been accessed.
*/
@Child(name = "entity", type = {}, order=9, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
- @Description(shortDefinition="Specific instances of data or objects that have been accessed", formalDefinition="Specific instances of data or objects that have been accessed." )
+ @Description(shortDefinition="Data or objects used", formalDefinition="Specific instances of data or objects that have been accessed." )
protected List entity;
private static final long serialVersionUID = 945153702L;
@@ -3137,7 +3151,7 @@ public class AuditEvent extends DomainResource {
}
/**
- * @return {@link #source} (Application systems and processes.)
+ * @return {@link #source} (The system that is reporting the event.)
*/
public AuditEventSourceComponent getSource() {
if (this.source == null)
@@ -3153,7 +3167,7 @@ public class AuditEvent extends DomainResource {
}
/**
- * @param value {@link #source} (Application systems and processes.)
+ * @param value {@link #source} (The system that is reporting the event.)
*/
public AuditEvent setSource(AuditEventSourceComponent value) {
this.source = value;
@@ -3223,7 +3237,7 @@ public class AuditEvent extends DomainResource {
childrenList.add(new Property("outcomeDesc", "string", "A free text description of the outcome of the event.", 0, java.lang.Integer.MAX_VALUE, outcomeDesc));
childrenList.add(new Property("purposeOfEvent", "Coding", "The purposeOfUse (reason) that was used during the event being recorded.", 0, java.lang.Integer.MAX_VALUE, purposeOfEvent));
childrenList.add(new Property("agent", "", "An actor taking an active role in the event or activity that is logged.", 0, java.lang.Integer.MAX_VALUE, agent));
- childrenList.add(new Property("source", "", "Application systems and processes.", 0, java.lang.Integer.MAX_VALUE, source));
+ childrenList.add(new Property("source", "", "The system that is reporting the event.", 0, java.lang.Integer.MAX_VALUE, source));
childrenList.add(new Property("entity", "", "Specific instances of data or objects that have been accessed.", 0, java.lang.Integer.MAX_VALUE, entity));
}
@@ -3448,7 +3462,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.recorded
*
*/
- @SearchParamDefinition(name="date", path="AuditEvent.recorded", description="Time when the event occurred on source", type="date", target={} )
+ @SearchParamDefinition(name="date", path="AuditEvent.recorded", description="Time when the event occurred on source", type="date" )
public static final String SP_DATE = "date";
/**
* Fluent Client search parameter constant for date
@@ -3463,17 +3477,17 @@ public class AuditEvent extends DomainResource {
/**
* Search parameter: entity-type
*
- * Description: Type of object involved
+ * Description: Type of entity involved
* Type: token
* Path: AuditEvent.entity.type
*
*/
- @SearchParamDefinition(name="entity-type", path="AuditEvent.entity.type", description="Type of object involved", type="token", target={} )
+ @SearchParamDefinition(name="entity-type", path="AuditEvent.entity.type", description="Type of entity involved", type="token" )
public static final String SP_ENTITY_TYPE = "entity-type";
/**
* Fluent Client search parameter constant for entity-type
*
- * Description: Type of object involved
+ * Description: Type of entity involved
* Type: token
* Path: AuditEvent.entity.type
*
@@ -3488,7 +3502,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.agent.reference
*
*/
- @SearchParamDefinition(name="agent", path="AuditEvent.agent.reference", description="Direct reference to resource", type="reference", target={Practitioner.class, Organization.class, Device.class, Patient.class, RelatedPerson.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner") } )
+ @SearchParamDefinition(name="agent", path="AuditEvent.agent.reference", description="Direct reference to resource", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Device"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner") } )
public static final String SP_AGENT = "agent";
/**
* Fluent Client search parameter constant for agent
@@ -3510,21 +3524,41 @@ public class AuditEvent extends DomainResource {
* Search parameter: address
*
* Description: Identifier for the network access point of the user device
- * Type: token
+ * Type: string
* Path: AuditEvent.agent.network.address
*
*/
- @SearchParamDefinition(name="address", path="AuditEvent.agent.network.address", description="Identifier for the network access point of the user device", type="token", target={} )
+ @SearchParamDefinition(name="address", path="AuditEvent.agent.network.address", description="Identifier for the network access point of the user device", type="string" )
public static final String SP_ADDRESS = "address";
/**
* Fluent Client search parameter constant for address
*
* Description: Identifier for the network access point of the user device
- * Type: token
+ * Type: string
* Path: AuditEvent.agent.network.address
*
*/
- public static final ca.uhn.fhir.rest.gclient.TokenClientParam ADDRESS = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_ADDRESS);
+ public static final ca.uhn.fhir.rest.gclient.StringClientParam ADDRESS = new ca.uhn.fhir.rest.gclient.StringClientParam(SP_ADDRESS);
+
+ /**
+ * Search parameter: role
+ *
+ * Description: What role the entity played
+ * Type: token
+ * Path: AuditEvent.entity.role
+ *
+ */
+ @SearchParamDefinition(name="role", path="AuditEvent.entity.role", description="What role the entity played", type="token" )
+ public static final String SP_ROLE = "role";
+ /**
+ * Fluent Client search parameter constant for role
+ *
+ * Description: What role the entity played
+ * Type: token
+ * Path: AuditEvent.entity.role
+ *
+ */
+ public static final ca.uhn.fhir.rest.gclient.TokenClientParam ROLE = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_ROLE);
/**
* Search parameter: source
@@ -3534,7 +3568,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.source.identifier
*
*/
- @SearchParamDefinition(name="source", path="AuditEvent.source.identifier", description="The identity of source detecting the event", type="token", target={} )
+ @SearchParamDefinition(name="source", path="AuditEvent.source.identifier", description="The identity of source detecting the event", type="token" )
public static final String SP_SOURCE = "source";
/**
* Fluent Client search parameter constant for source
@@ -3554,7 +3588,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.type
*
*/
- @SearchParamDefinition(name="type", path="AuditEvent.type", description="Type/identifier of event", type="token", target={} )
+ @SearchParamDefinition(name="type", path="AuditEvent.type", description="Type/identifier of event", type="token" )
public static final String SP_TYPE = "type";
/**
* Fluent Client search parameter constant for type
@@ -3574,7 +3608,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.agent.altId
*
*/
- @SearchParamDefinition(name="altid", path="AuditEvent.agent.altId", description="Alternative User id e.g. authentication", type="token", target={} )
+ @SearchParamDefinition(name="altid", path="AuditEvent.agent.altId", description="Alternative User id e.g. authentication", type="token" )
public static final String SP_ALTID = "altid";
/**
* Fluent Client search parameter constant for altid
@@ -3594,7 +3628,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.source.site
*
*/
- @SearchParamDefinition(name="site", path="AuditEvent.source.site", description="Logical source location within the enterprise", type="token", target={} )
+ @SearchParamDefinition(name="site", path="AuditEvent.source.site", description="Logical source location within the enterprise", type="token" )
public static final String SP_SITE = "site";
/**
* Fluent Client search parameter constant for site
@@ -3614,7 +3648,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.agent.name
*
*/
- @SearchParamDefinition(name="agent-name", path="AuditEvent.agent.name", description="Human-meaningful name for the agent", type="string", target={} )
+ @SearchParamDefinition(name="agent-name", path="AuditEvent.agent.name", description="Human-meaningful name for the agent", type="string" )
public static final String SP_AGENT_NAME = "agent-name";
/**
* Fluent Client search parameter constant for agent-name
@@ -3634,7 +3668,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.entity.name
*
*/
- @SearchParamDefinition(name="entity-name", path="AuditEvent.entity.name", description="Descriptor for entity", type="string", target={} )
+ @SearchParamDefinition(name="entity-name", path="AuditEvent.entity.name", description="Descriptor for entity", type="string" )
public static final String SP_ENTITY_NAME = "entity-name";
/**
* Fluent Client search parameter constant for entity-name
@@ -3654,7 +3688,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.subtype
*
*/
- @SearchParamDefinition(name="subtype", path="AuditEvent.subtype", description="More specific type/id for the event", type="token", target={} )
+ @SearchParamDefinition(name="subtype", path="AuditEvent.subtype", description="More specific type/id for the event", type="token" )
public static final String SP_SUBTYPE = "subtype";
/**
* Fluent Client search parameter constant for subtype
@@ -3674,7 +3708,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.agent.reference, AuditEvent.entity.reference
*
*/
- @SearchParamDefinition(name="patient", path="AuditEvent.agent.reference | AuditEvent.entity.reference", description="Direct reference to resource", type="reference", target={Patient.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
+ @SearchParamDefinition(name="patient", path="AuditEvent.agent.reference | AuditEvent.entity.reference", description="Direct reference to resource", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
public static final String SP_PATIENT = "patient";
/**
* Fluent Client search parameter constant for patient
@@ -3700,7 +3734,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.action
*
*/
- @SearchParamDefinition(name="action", path="AuditEvent.action", description="Type of action performed during the event", type="token", target={} )
+ @SearchParamDefinition(name="action", path="AuditEvent.action", description="Type of action performed during the event", type="token" )
public static final String SP_ACTION = "action";
/**
* Fluent Client search parameter constant for action
@@ -3720,7 +3754,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.agent.userId
*
*/
- @SearchParamDefinition(name="user", path="AuditEvent.agent.userId", description="Unique identifier for the user", type="token", target={} )
+ @SearchParamDefinition(name="user", path="AuditEvent.agent.userId", description="Unique identifier for the user", type="token" )
public static final String SP_USER = "user";
/**
* Fluent Client search parameter constant for user
@@ -3735,17 +3769,17 @@ public class AuditEvent extends DomainResource {
/**
* Search parameter: entity
*
- * Description: Specific instance of resource (e.g. versioned)
+ * Description: Specific instance of resource
* Type: reference
* Path: AuditEvent.entity.reference
*
*/
- @SearchParamDefinition(name="entity", path="AuditEvent.entity.reference", description="Specific instance of resource (e.g. versioned)", type="reference" )
+ @SearchParamDefinition(name="entity", path="AuditEvent.entity.reference", description="Specific instance of resource", type="reference" )
public static final String SP_ENTITY = "entity";
/**
* Fluent Client search parameter constant for entity
*
- * Description: Specific instance of resource (e.g. versioned)
+ * Description: Specific instance of resource
* Type: reference
* Path: AuditEvent.entity.reference
*
@@ -3761,23 +3795,43 @@ public class AuditEvent extends DomainResource {
/**
* Search parameter: entity-id
*
- * Description: Specific instance of object (e.g. versioned)
+ * Description: Specific instance of object
* Type: token
* Path: AuditEvent.entity.identifier
*
*/
- @SearchParamDefinition(name="entity-id", path="AuditEvent.entity.identifier", description="Specific instance of object (e.g. versioned)", type="token", target={} )
+ @SearchParamDefinition(name="entity-id", path="AuditEvent.entity.identifier", description="Specific instance of object", type="token" )
public static final String SP_ENTITY_ID = "entity-id";
/**
* Fluent Client search parameter constant for entity-id
*
- * Description: Specific instance of object (e.g. versioned)
+ * Description: Specific instance of object
* Type: token
* Path: AuditEvent.entity.identifier
*
*/
public static final ca.uhn.fhir.rest.gclient.TokenClientParam ENTITY_ID = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_ENTITY_ID);
+ /**
+ * Search parameter: outcome
+ *
+ * Description: Whether the event succeeded or failed
+ * Type: token
+ * Path: AuditEvent.outcome
+ *
+ */
+ @SearchParamDefinition(name="outcome", path="AuditEvent.outcome", description="Whether the event succeeded or failed", type="token" )
+ public static final String SP_OUTCOME = "outcome";
+ /**
+ * Fluent Client search parameter constant for outcome
+ *
+ * Description: Whether the event succeeded or failed
+ * Type: token
+ * Path: AuditEvent.outcome
+ *
+ */
+ public static final ca.uhn.fhir.rest.gclient.TokenClientParam OUTCOME = new ca.uhn.fhir.rest.gclient.TokenClientParam(SP_OUTCOME);
+
/**
* Search parameter: policy
*
@@ -3786,7 +3840,7 @@ public class AuditEvent extends DomainResource {
* Path: AuditEvent.agent.policy
*
*/
- @SearchParamDefinition(name="policy", path="AuditEvent.agent.policy", description="Policy that authorized event", type="uri", target={} )
+ @SearchParamDefinition(name="policy", path="AuditEvent.agent.policy", description="Policy that authorized event", type="uri" )
public static final String SP_POLICY = "policy";
/**
* Fluent Client search parameter constant for policy
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/BackboneElement.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/BackboneElement.java
index c2c829eb7c7..bfbd6377973 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/BackboneElement.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/BackboneElement.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sat, May 28, 2016 10:02-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Base.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Base.java
index 0078d75a93d..c4a0dbe793c 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Base.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Base.java
@@ -170,11 +170,11 @@ private Map userData;
}
public boolean equalsDeep(Base other) {
- return other != null;
+ return other == this;
}
public boolean equalsShallow(Base other) {
- return other != null;
+ return other == this;
}
public static boolean compareDeep(List extends Base> e1, List extends Base> e2, boolean allowNull) {
@@ -494,7 +494,35 @@ private Map userData;
else
throw new FHIRException("Unable to convert a "+b.getClass().getName()+" to a Address");
}
-
+
+ public ContactDetail castToContactDetail(Base b) throws FHIRException {
+ if (b instanceof ContactDetail)
+ return (ContactDetail) b;
+ else
+ throw new FHIRException("Unable to convert a "+b.getClass().getName()+" to a ContactDetail");
+ }
+
+ public Contributor castToContributor(Base b) throws FHIRException {
+ if (b instanceof Contributor)
+ return (Contributor) b;
+ else
+ throw new FHIRException("Unable to convert a "+b.getClass().getName()+" to a Contributor");
+ }
+
+ public UsageContext castToUsageContext(Base b) throws FHIRException {
+ if (b instanceof UsageContext)
+ return (UsageContext) b;
+ else
+ throw new FHIRException("Unable to convert a "+b.getClass().getName()+" to a UsageContext");
+ }
+
+ public RelatedResource castToRelatedResource(Base b) throws FHIRException {
+ if (b instanceof RelatedResource)
+ return (RelatedResource) b;
+ else
+ throw new FHIRException("Unable to convert a "+b.getClass().getName()+" to a RelatedResource");
+ }
+
public ContactPoint castToContactPoint(Base b) throws FHIRException {
if (b instanceof ContactPoint)
return (ContactPoint) b;
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Basic.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Basic.java
index fe12e83ac56..d335fbb428a 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Basic.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Basic.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -59,6 +59,7 @@ public class Basic extends DomainResource {
*/
@Child(name = "code", type = {CodeableConcept.class}, order=1, min=1, max=1, modifier=true, summary=true)
@Description(shortDefinition="Kind of Resource", formalDefinition="Identifies the 'type' of resource - equivalent to the resource name for other resources." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/basic-resource-type")
protected CodeableConcept code;
/**
@@ -474,7 +475,7 @@ public class Basic extends DomainResource {
* Path: Basic.identifier
*
*/
- @SearchParamDefinition(name="identifier", path="Basic.identifier", description="Business identifier", type="token", target={} )
+ @SearchParamDefinition(name="identifier", path="Basic.identifier", description="Business identifier", type="token" )
public static final String SP_IDENTIFIER = "identifier";
/**
* Fluent Client search parameter constant for identifier
@@ -494,7 +495,7 @@ public class Basic extends DomainResource {
* Path: Basic.code
*
*/
- @SearchParamDefinition(name="code", path="Basic.code", description="Kind of Resource", type="token", target={} )
+ @SearchParamDefinition(name="code", path="Basic.code", description="Kind of Resource", type="token" )
public static final String SP_CODE = "code";
/**
* Fluent Client search parameter constant for code
@@ -540,7 +541,7 @@ public class Basic extends DomainResource {
* Path: Basic.created
*
*/
- @SearchParamDefinition(name="created", path="Basic.created", description="When created", type="date", target={} )
+ @SearchParamDefinition(name="created", path="Basic.created", description="When created", type="date" )
public static final String SP_CREATED = "created";
/**
* Fluent Client search parameter constant for created
@@ -560,7 +561,7 @@ public class Basic extends DomainResource {
* Path: Basic.subject
*
*/
- @SearchParamDefinition(name="patient", path="Basic.subject", description="Identifies the focus of this resource", type="reference", target={Patient.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
+ @SearchParamDefinition(name="patient", path="Basic.subject", description="Identifies the focus of this resource", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
public static final String SP_PATIENT = "patient";
/**
* Fluent Client search parameter constant for patient
@@ -586,7 +587,7 @@ public class Basic extends DomainResource {
* Path: Basic.author
*
*/
- @SearchParamDefinition(name="author", path="Basic.author", description="Who created", type="reference", target={Practitioner.class, Patient.class, RelatedPerson.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
+ @SearchParamDefinition(name="author", path="Basic.author", description="Who created", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
public static final String SP_AUTHOR = "author";
/**
* Fluent Client search parameter constant for author
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Binary.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Binary.java
index eba853187d4..bfcd3c7f858 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Binary.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Binary.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -287,7 +287,7 @@ public class Binary extends BaseBinary implements IBaseBinary {
* Path: Binary.contentType
*
*/
- @SearchParamDefinition(name="contenttype", path="Binary.contentType", description="MimeType of the binary content", type="token", target={} )
+ @SearchParamDefinition(name="contenttype", path="Binary.contentType", description="MimeType of the binary content", type="token" )
public static final String SP_CONTENTTYPE = "contenttype";
/**
* Fluent Client search parameter constant for contenttype
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/BodySite.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/BodySite.java
index 31dd1726ae1..f69c21b0307 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/BodySite.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/BodySite.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -72,6 +72,7 @@ public class BodySite extends DomainResource {
*/
@Child(name = "code", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="Named anatomical location", formalDefinition="Named anatomical location - ideally coded where possible." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/body-site")
protected CodeableConcept code;
/**
@@ -79,6 +80,7 @@ public class BodySite extends DomainResource {
*/
@Child(name = "modifier", type = {CodeableConcept.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Modification to location code", formalDefinition="Modifier to refine the anatomical location. These include modifiers for laterality, relative location, directionality, number, and plane." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/bodysite-relative-location")
protected List modifier;
/**
@@ -569,7 +571,7 @@ public class BodySite extends DomainResource {
* Path: BodySite.identifier
*
*/
- @SearchParamDefinition(name="identifier", path="BodySite.identifier", description="Identifier for this instance of the anatomical location", type="token", target={} )
+ @SearchParamDefinition(name="identifier", path="BodySite.identifier", description="Identifier for this instance of the anatomical location", type="token" )
public static final String SP_IDENTIFIER = "identifier";
/**
* Fluent Client search parameter constant for identifier
@@ -589,7 +591,7 @@ public class BodySite extends DomainResource {
* Path: BodySite.code
*
*/
- @SearchParamDefinition(name="code", path="BodySite.code", description="Named anatomical location", type="token", target={} )
+ @SearchParamDefinition(name="code", path="BodySite.code", description="Named anatomical location", type="token" )
public static final String SP_CODE = "code";
/**
* Fluent Client search parameter constant for code
@@ -609,7 +611,7 @@ public class BodySite extends DomainResource {
* Path: BodySite.patient
*
*/
- @SearchParamDefinition(name="patient", path="BodySite.patient", description="Patient to whom bodysite belongs", type="reference", target={Patient.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
+ @SearchParamDefinition(name="patient", path="BodySite.patient", description="Patient to whom bodysite belongs", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
public static final String SP_PATIENT = "patient";
/**
* Fluent Client search parameter constant for patient
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Bundle.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Bundle.java
index 7483c8f5209..ca8bae31794 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Bundle.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Bundle.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -1173,6 +1173,7 @@ public class Bundle extends Resource implements IBaseBundle {
*/
@Child(name = "mode", type = {CodeType.class}, order=1, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="match | include | outcome - why this is in the result set", formalDefinition="Why this entry is in the result set - whether it's included as a match or because of an _include requirement." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/search-entry-mode")
protected Enumeration mode;
/**
@@ -1415,6 +1416,7 @@ public class Bundle extends Resource implements IBaseBundle {
*/
@Child(name = "method", type = {CodeType.class}, order=1, min=1, max=1, modifier=false, summary=true)
@Description(shortDefinition="GET | POST | PUT | DELETE", formalDefinition="The HTTP verb for this entry in either a change history, or a transaction/ transaction response." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/http-verb")
protected Enumeration method;
/**
@@ -2282,6 +2284,7 @@ public class Bundle extends Resource implements IBaseBundle {
*/
@Child(name = "type", type = {CodeType.class}, order=0, min=1, max=1, modifier=false, summary=true)
@Description(shortDefinition="document | message | transaction | transaction-response | batch | batch-response | history | searchset | collection", formalDefinition="Indicates the purpose of this bundle- how it was intended to be used." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/bundle-type")
protected Enumeration type;
/**
@@ -2759,7 +2762,7 @@ public class Bundle extends Resource implements IBaseBundle {
* Path: Bundle.entry.resource(0)
*
*/
- @SearchParamDefinition(name="composition", path="Bundle.entry.resource[0]", description="The first resource in the bundle, if the bundle type is \"document\" - this is a composition, and this parameter provides access to searches its contents", type="reference", target={Composition.class} )
+ @SearchParamDefinition(name="composition", path="Bundle.entry.resource[0]", description="The first resource in the bundle, if the bundle type is \"document\" - this is a composition, and this parameter provides access to searches its contents", type="reference" )
public static final String SP_COMPOSITION = "composition";
/**
* Fluent Client search parameter constant for composition
@@ -2785,7 +2788,7 @@ public class Bundle extends Resource implements IBaseBundle {
* Path: Bundle.type
*
*/
- @SearchParamDefinition(name="type", path="Bundle.type", description="document | message | transaction | transaction-response | batch | batch-response | history | searchset | collection", type="token", target={} )
+ @SearchParamDefinition(name="type", path="Bundle.type", description="document | message | transaction | transaction-response | batch | batch-response | history | searchset | collection", type="token" )
public static final String SP_TYPE = "type";
/**
* Fluent Client search parameter constant for type
@@ -2805,7 +2808,7 @@ public class Bundle extends Resource implements IBaseBundle {
* Path: Bundle.entry.resource(0)
*
*/
- @SearchParamDefinition(name="message", path="Bundle.entry.resource[0]", description="The first resource in the bundle, if the bundle type is \"message\" - this is a message header, and this parameter provides access to search its contents", type="reference", target={MessageHeader.class} )
+ @SearchParamDefinition(name="message", path="Bundle.entry.resource[0]", description="The first resource in the bundle, if the bundle type is \"message\" - this is a message header, and this parameter provides access to search its contents", type="reference" )
public static final String SP_MESSAGE = "message";
/**
* Fluent Client search parameter constant for message
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/CarePlan.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/CarePlan.java
index ec3fe1de7ef..d249150db67 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/CarePlan.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/CarePlan.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -453,6 +453,7 @@ public class CarePlan extends DomainResource {
*/
@Child(name = "code", type = {CodeType.class}, order=1, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="includes | replaces | fulfills", formalDefinition="Identifies the type of relationship this plan has to the target plan." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/care-plan-relationship")
protected Enumeration code;
/**
@@ -1051,6 +1052,7 @@ public class CarePlan extends DomainResource {
*/
@Child(name = "category", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="diet | drug | encounter | observation | procedure | supply | other", formalDefinition="High-level categorization of the type of activity in a care plan." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/care-plan-activity-category")
protected CodeableConcept category;
/**
@@ -1058,6 +1060,7 @@ public class CarePlan extends DomainResource {
*/
@Child(name = "code", type = {CodeableConcept.class}, order=2, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Detail type of activity", formalDefinition="Detailed description of the type of planned activity; e.g. What lab test, what procedure, what kind of encounter." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/care-plan-activity")
protected CodeableConcept code;
/**
@@ -1065,6 +1068,7 @@ public class CarePlan extends DomainResource {
*/
@Child(name = "reasonCode", type = {CodeableConcept.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Why activity should be done", formalDefinition="Provides the rationale that drove the inclusion of this particular activity as part of the plan." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/activity-reason")
protected List reasonCode;
/**
@@ -1096,6 +1100,7 @@ public class CarePlan extends DomainResource {
*/
@Child(name = "status", type = {CodeType.class}, order=6, min=0, max=1, modifier=true, summary=false)
@Description(shortDefinition="not-started | scheduled | in-progress | on-hold | completed | cancelled", formalDefinition="Identifies what progress is being made for the specific activity." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/care-plan-activity-status")
protected Enumeration status;
/**
@@ -1103,6 +1108,7 @@ public class CarePlan extends DomainResource {
*/
@Child(name = "statusReason", type = {CodeableConcept.class}, order=7, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Reason for current status", formalDefinition="Provides reason why the activity isn't yet started, is on hold, was cancelled, etc." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/goal-status-reason")
protected CodeableConcept statusReason;
/**
@@ -1148,6 +1154,7 @@ public class CarePlan extends DomainResource {
*/
@Child(name = "product", type = {CodeableConcept.class, Medication.class, Substance.class}, order=12, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="What is to be administered/supplied", formalDefinition="Identifies the food, drug or other product to be consumed or supplied in the activity." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/medication-codes")
protected Type product;
/**
@@ -2189,6 +2196,7 @@ public class CarePlan extends DomainResource {
*/
@Child(name = "status", type = {CodeType.class}, order=2, min=1, max=1, modifier=true, summary=true)
@Description(shortDefinition="proposed | draft | active | completed | cancelled", formalDefinition="Indicates whether the plan is currently being acted upon, represents future intentions or is now a historical record." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/care-plan-status")
protected Enumeration status;
/**
@@ -2234,6 +2242,7 @@ public class CarePlan extends DomainResource {
*/
@Child(name = "category", type = {CodeableConcept.class}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
@Description(shortDefinition="Type of plan", formalDefinition="Identifies what \"kind\" of plan this is to support differentiation between multiple co-existing plans; e.g. \"Home health\", \"psychiatric\", \"asthma\", \"disease management\", \"wellness plan\", etc." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/care-plan-category")
protected List category;
/**
@@ -3459,7 +3468,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.period
*
*/
- @SearchParamDefinition(name="date", path="CarePlan.period", description="Time period plan covers", type="date", target={} )
+ @SearchParamDefinition(name="date", path="CarePlan.period", description="Time period plan covers", type="date" )
public static final String SP_DATE = "date";
/**
* Fluent Client search parameter constant for date
@@ -3479,7 +3488,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.activity.detail.code
*
*/
- @SearchParamDefinition(name="activitycode", path="CarePlan.activity.detail.code", description="Detail type of activity", type="token", target={} )
+ @SearchParamDefinition(name="activitycode", path="CarePlan.activity.detail.code", description="Detail type of activity", type="token" )
public static final String SP_ACTIVITYCODE = "activitycode";
/**
* Fluent Client search parameter constant for activitycode
@@ -3499,7 +3508,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.activity.detail.scheduled[x]
*
*/
- @SearchParamDefinition(name="activitydate", path="CarePlan.activity.detail.scheduled", description="Specified date occurs within period specified by CarePlan.activity.timingSchedule", type="date", target={} )
+ @SearchParamDefinition(name="activitydate", path="CarePlan.activity.detail.scheduled", description="Specified date occurs within period specified by CarePlan.activity.timingSchedule", type="date" )
public static final String SP_ACTIVITYDATE = "activitydate";
/**
* Fluent Client search parameter constant for activitydate
@@ -3519,7 +3528,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.activity.reference
*
*/
- @SearchParamDefinition(name="activityreference", path="CarePlan.activity.reference", description="Activity details defined in specific resource", type="reference", target={Appointment.class, Order.class, ReferralRequest.class, ProcessRequest.class, NutritionOrder.class, VisionPrescription.class, DiagnosticOrder.class, ProcedureRequest.class, DeviceUseRequest.class, MedicationOrder.class, CommunicationRequest.class, SupplyRequest.class} )
+ @SearchParamDefinition(name="activityreference", path="CarePlan.activity.reference", description="Activity details defined in specific resource", type="reference" )
public static final String SP_ACTIVITYREFERENCE = "activityreference";
/**
* Fluent Client search parameter constant for activityreference
@@ -3545,7 +3554,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.activity.detail.performer
*
*/
- @SearchParamDefinition(name="performer", path="CarePlan.activity.detail.performer", description="Matches if the practitioner is listed as a performer in any of the \"simple\" activities. (For performers of the detailed activities, chain through the activitydetail search parameter.)", type="reference", target={Practitioner.class, Organization.class, Patient.class, RelatedPerson.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
+ @SearchParamDefinition(name="performer", path="CarePlan.activity.detail.performer", description="Matches if the practitioner is listed as a performer in any of the \"simple\" activities. (For performers of the detailed activities, chain through the activitydetail search parameter.)", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
public static final String SP_PERFORMER = "performer";
/**
* Fluent Client search parameter constant for performer
@@ -3571,7 +3580,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.goal
*
*/
- @SearchParamDefinition(name="goal", path="CarePlan.goal", description="Desired outcome of plan", type="reference", target={Goal.class} )
+ @SearchParamDefinition(name="goal", path="CarePlan.goal", description="Desired outcome of plan", type="reference" )
public static final String SP_GOAL = "goal";
/**
* Fluent Client search parameter constant for goal
@@ -3597,7 +3606,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.subject
*
*/
- @SearchParamDefinition(name="subject", path="CarePlan.subject", description="Who care plan is for", type="reference", target={Group.class, Patient.class} )
+ @SearchParamDefinition(name="subject", path="CarePlan.subject", description="Who care plan is for", type="reference" )
public static final String SP_SUBJECT = "subject";
/**
* Fluent Client search parameter constant for subject
@@ -3623,7 +3632,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.relatedPlan.code
*
*/
- @SearchParamDefinition(name="relatedcode", path="CarePlan.relatedPlan.code", description="includes | replaces | fulfills", type="token", target={} )
+ @SearchParamDefinition(name="relatedcode", path="CarePlan.relatedPlan.code", description="includes | replaces | fulfills", type="token" )
public static final String SP_RELATEDCODE = "relatedcode";
/**
* Fluent Client search parameter constant for relatedcode
@@ -3643,7 +3652,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.careTeam
*
*/
- @SearchParamDefinition(name="careteam", path="CarePlan.careTeam", description="Who's involved in plan?", type="reference", target={CareTeam.class} )
+ @SearchParamDefinition(name="careteam", path="CarePlan.careTeam", description="Who's involved in plan?", type="reference" )
public static final String SP_CARETEAM = "careteam";
/**
* Fluent Client search parameter constant for careteam
@@ -3669,7 +3678,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.relatedPlan.plan
*
*/
- @SearchParamDefinition(name="relatedplan", path="CarePlan.relatedPlan.plan", description="Plan relationship exists with", type="reference", target={CarePlan.class} )
+ @SearchParamDefinition(name="relatedplan", path="CarePlan.relatedPlan.plan", description="Plan relationship exists with", type="reference" )
public static final String SP_RELATEDPLAN = "relatedplan";
/**
* Fluent Client search parameter constant for relatedplan
@@ -3695,7 +3704,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.addresses
*
*/
- @SearchParamDefinition(name="condition", path="CarePlan.addresses", description="Health issues this plan addresses", type="reference", target={Condition.class} )
+ @SearchParamDefinition(name="condition", path="CarePlan.addresses", description="Health issues this plan addresses", type="reference" )
public static final String SP_CONDITION = "condition";
/**
* Fluent Client search parameter constant for condition
@@ -3721,7 +3730,7 @@ public class CarePlan extends DomainResource {
* Path:
*
*/
- @SearchParamDefinition(name="related", path="", description="A combination of the type of relationship and the related plan", type="composite", compositeOf={"relatedcode", "relatedplan"}, target={} )
+ @SearchParamDefinition(name="related", path="", description="A combination of the type of relationship and the related plan", type="composite", compositeOf={"relatedcode", "relatedplan"} )
public static final String SP_RELATED = "related";
/**
* Fluent Client search parameter constant for related
@@ -3741,7 +3750,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.subject
*
*/
- @SearchParamDefinition(name="patient", path="CarePlan.subject", description="Who care plan is for", type="reference", target={Patient.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
+ @SearchParamDefinition(name="patient", path="CarePlan.subject", description="Who care plan is for", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
public static final String SP_PATIENT = "patient";
/**
* Fluent Client search parameter constant for patient
@@ -3767,7 +3776,7 @@ public class CarePlan extends DomainResource {
* Path: CarePlan.category
*
*/
- @SearchParamDefinition(name="category", path="CarePlan.category", description="Type of plan", type="token", target={} )
+ @SearchParamDefinition(name="category", path="CarePlan.category", description="Type of plan", type="token" )
public static final String SP_CATEGORY = "category";
/**
* Fluent Client search parameter constant for category
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/CareTeam.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/CareTeam.java
index a7bff2c7eb4..954b7945b1c 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/CareTeam.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/CareTeam.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -55,6 +55,7 @@ public class CareTeam extends DomainResource {
*/
@Child(name = "role", type = {CodeableConcept.class}, order=1, min=0, max=1, modifier=false, summary=true)
@Description(shortDefinition="Type of involvement", formalDefinition="Indicates specific responsibility of an individual within the care team, such as \"Primary physician\", \"Team coordinator\", \"Caregiver\", etc." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/participant-role")
protected CodeableConcept role;
/**
@@ -911,7 +912,7 @@ public class CareTeam extends DomainResource {
* Path: CareTeam.period
*
*/
- @SearchParamDefinition(name="date", path="CareTeam.period", description="Time period team covers", type="date", target={} )
+ @SearchParamDefinition(name="date", path="CareTeam.period", description="Time period team covers", type="date" )
public static final String SP_DATE = "date";
/**
* Fluent Client search parameter constant for date
@@ -931,7 +932,7 @@ public class CareTeam extends DomainResource {
* Path: CareTeam.identifier
*
*/
- @SearchParamDefinition(name="identifier", path="CareTeam.identifier", description="External Ids for this team", type="token", target={} )
+ @SearchParamDefinition(name="identifier", path="CareTeam.identifier", description="External Ids for this team", type="token" )
public static final String SP_IDENTIFIER = "identifier";
/**
* Fluent Client search parameter constant for identifier
@@ -951,7 +952,7 @@ public class CareTeam extends DomainResource {
* Path: CareTeam.subject
*
*/
- @SearchParamDefinition(name="patient", path="CareTeam.subject", description="Who care team is for", type="reference", target={Patient.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
+ @SearchParamDefinition(name="patient", path="CareTeam.subject", description="Who care team is for", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient") } )
public static final String SP_PATIENT = "patient";
/**
* Fluent Client search parameter constant for patient
@@ -977,7 +978,7 @@ public class CareTeam extends DomainResource {
* Path: CareTeam.subject
*
*/
- @SearchParamDefinition(name="subject", path="CareTeam.subject", description="Who care team is for", type="reference", target={Group.class, Patient.class} )
+ @SearchParamDefinition(name="subject", path="CareTeam.subject", description="Who care team is for", type="reference" )
public static final String SP_SUBJECT = "subject";
/**
* Fluent Client search parameter constant for subject
@@ -1003,7 +1004,7 @@ public class CareTeam extends DomainResource {
* Path: CareTeam.type
*
*/
- @SearchParamDefinition(name="type", path="CareTeam.type", description="Type of team", type="token", target={} )
+ @SearchParamDefinition(name="type", path="CareTeam.type", description="Type of team", type="token" )
public static final String SP_TYPE = "type";
/**
* Fluent Client search parameter constant for type
@@ -1023,7 +1024,7 @@ public class CareTeam extends DomainResource {
* Path: CareTeam.participant.member
*
*/
- @SearchParamDefinition(name="participant", path="CareTeam.participant.member", description="Who is involved", type="reference", target={Practitioner.class, Organization.class, Patient.class, RelatedPerson.class}, providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
+ @SearchParamDefinition(name="participant", path="CareTeam.participant.member", description="Who is involved", type="reference", providesMembershipIn={ @ca.uhn.fhir.model.api.annotation.Compartment(name="Patient"), @ca.uhn.fhir.model.api.annotation.Compartment(name="Practitioner"), @ca.uhn.fhir.model.api.annotation.Compartment(name="RelatedPerson") } )
public static final String SP_PARTICIPANT = "participant";
/**
* Fluent Client search parameter constant for participant
@@ -1049,7 +1050,7 @@ public class CareTeam extends DomainResource {
* Path: CareTeam.status
*
*/
- @SearchParamDefinition(name="status", path="CareTeam.status", description="active | suspended | inactive | entered in error", type="token", target={} )
+ @SearchParamDefinition(name="status", path="CareTeam.status", description="active | suspended | inactive | entered in error", type="token" )
public static final String SP_STATUS = "status";
/**
* Fluent Client search parameter constant for status
diff --git a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Claim.java b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Claim.java
index e19fb3fddf9..fceab51e72c 100644
--- a/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Claim.java
+++ b/hapi-fhir-structures-dstu3/src/main/java/org/hl7/fhir/dstu3/model/Claim.java
@@ -29,7 +29,7 @@ package org.hl7.fhir.dstu3.model;
*/
-// Generated on Sun, May 29, 2016 16:57-0400 for FHIR v1.4.0
+// Generated on Fri, Jul 1, 2016 14:13-0400 for FHIR v1.4.0
import java.util.*;
@@ -50,140 +50,124 @@ import org.hl7.fhir.dstu3.exceptions.FHIRException;
@ResourceDef(name="Claim", profile="http://hl7.org/fhir/Profile/Claim")
public class Claim extends DomainResource {
- public enum ClaimType {
+ public enum ClaimStatus {
/**
- * A claim for Institution based, typically in-patient, goods and services.
+ * The resource instance is currently in-force.
*/
- INSTITUTIONAL,
+ ACTIVE,
/**
- * A claim for Oral Health (Dentist, Denturist, Hygienist) goods and services.
+ * The resource instance is withdrawn, rescinded or reversed.
*/
- ORAL,
+ CANCELLED,
/**
- * A claim for Pharmacy based goods and services.
+ * A new resource instance the contents of which is not complete.
*/
- PHARMACY,
+ DRAFT,
/**
- * A claim for Professional, typically out-patient, goods and services.
+ * The resource instance was entered in error.
*/
- PROFESSIONAL,
- /**
- * A claim for Vision (Opthamologist, Optometrist and Optician) goods and services.
- */
- VISION,
+ ENTEREDINERROR,
/**
* added to help the parsers with the generic types
*/
NULL;
- public static ClaimType fromCode(String codeString) throws FHIRException {
+ public static ClaimStatus fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
- if ("institutional".equals(codeString))
- return INSTITUTIONAL;
- if ("oral".equals(codeString))
- return ORAL;
- if ("pharmacy".equals(codeString))
- return PHARMACY;
- if ("professional".equals(codeString))
- return PROFESSIONAL;
- if ("vision".equals(codeString))
- return VISION;
+ if ("active".equals(codeString))
+ return ACTIVE;
+ if ("cancelled".equals(codeString))
+ return CANCELLED;
+ if ("draft".equals(codeString))
+ return DRAFT;
+ if ("entered-in-error".equals(codeString))
+ return ENTEREDINERROR;
if (Configuration.isAcceptInvalidEnums())
return null;
else
- throw new FHIRException("Unknown ClaimType code '"+codeString+"'");
+ throw new FHIRException("Unknown ClaimStatus code '"+codeString+"'");
}
public String toCode() {
switch (this) {
- case INSTITUTIONAL: return "institutional";
- case ORAL: return "oral";
- case PHARMACY: return "pharmacy";
- case PROFESSIONAL: return "professional";
- case VISION: return "vision";
+ case ACTIVE: return "active";
+ case CANCELLED: return "cancelled";
+ case DRAFT: return "draft";
+ case ENTEREDINERROR: return "entered-in-error";
default: return "?";
}
}
public String getSystem() {
switch (this) {
- case INSTITUTIONAL: return "http://hl7.org/fhir/claim-type-link";
- case ORAL: return "http://hl7.org/fhir/claim-type-link";
- case PHARMACY: return "http://hl7.org/fhir/claim-type-link";
- case PROFESSIONAL: return "http://hl7.org/fhir/claim-type-link";
- case VISION: return "http://hl7.org/fhir/claim-type-link";
+ case ACTIVE: return "http://hl7.org/fhir/claim-status";
+ case CANCELLED: return "http://hl7.org/fhir/claim-status";
+ case DRAFT: return "http://hl7.org/fhir/claim-status";
+ case ENTEREDINERROR: return "http://hl7.org/fhir/claim-status";
default: return "?";
}
}
public String getDefinition() {
switch (this) {
- case INSTITUTIONAL: return "A claim for Institution based, typically in-patient, goods and services.";
- case ORAL: return "A claim for Oral Health (Dentist, Denturist, Hygienist) goods and services.";
- case PHARMACY: return "A claim for Pharmacy based goods and services.";
- case PROFESSIONAL: return "A claim for Professional, typically out-patient, goods and services.";
- case VISION: return "A claim for Vision (Opthamologist, Optometrist and Optician) goods and services.";
+ case ACTIVE: return "The resource instance is currently in-force.";
+ case CANCELLED: return "The resource instance is withdrawn, rescinded or reversed.";
+ case DRAFT: return "A new resource instance the contents of which is not complete.";
+ case ENTEREDINERROR: return "The resource instance was entered in error.";
default: return "?";
}
}
public String getDisplay() {
switch (this) {
- case INSTITUTIONAL: return "Institutional";
- case ORAL: return "Oral Health";
- case PHARMACY: return "Pharmacy";
- case PROFESSIONAL: return "Professional";
- case VISION: return "Vision";
+ case ACTIVE: return "Active";
+ case CANCELLED: return "Cancelled";
+ case DRAFT: return "Draft";
+ case ENTEREDINERROR: return "Entered In Error";
default: return "?";
}
}
}
- public static class ClaimTypeEnumFactory implements EnumFactory {
- public ClaimType fromCode(String codeString) throws IllegalArgumentException {
+ public static class ClaimStatusEnumFactory implements EnumFactory {
+ public ClaimStatus fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
- if ("institutional".equals(codeString))
- return ClaimType.INSTITUTIONAL;
- if ("oral".equals(codeString))
- return ClaimType.ORAL;
- if ("pharmacy".equals(codeString))
- return ClaimType.PHARMACY;
- if ("professional".equals(codeString))
- return ClaimType.PROFESSIONAL;
- if ("vision".equals(codeString))
- return ClaimType.VISION;
- throw new IllegalArgumentException("Unknown ClaimType code '"+codeString+"'");
+ if ("active".equals(codeString))
+ return ClaimStatus.ACTIVE;
+ if ("cancelled".equals(codeString))
+ return ClaimStatus.CANCELLED;
+ if ("draft".equals(codeString))
+ return ClaimStatus.DRAFT;
+ if ("entered-in-error".equals(codeString))
+ return ClaimStatus.ENTEREDINERROR;
+ throw new IllegalArgumentException("Unknown ClaimStatus code '"+codeString+"'");
}
- public Enumeration fromType(Base code) throws FHIRException {
+ public Enumeration fromType(Base code) throws FHIRException {
if (code == null || code.isEmpty())
return null;
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return null;
- if ("institutional".equals(codeString))
- return new Enumeration(this, ClaimType.INSTITUTIONAL);
- if ("oral".equals(codeString))
- return new Enumeration(this, ClaimType.ORAL);
- if ("pharmacy".equals(codeString))
- return new Enumeration(this, ClaimType.PHARMACY);
- if ("professional".equals(codeString))
- return new Enumeration(this, ClaimType.PROFESSIONAL);
- if ("vision".equals(codeString))
- return new Enumeration(this, ClaimType.VISION);
- throw new FHIRException("Unknown ClaimType code '"+codeString+"'");
+ if ("active".equals(codeString))
+ return new Enumeration(this, ClaimStatus.ACTIVE);
+ if ("cancelled".equals(codeString))
+ return new Enumeration(this, ClaimStatus.CANCELLED);
+ if ("draft".equals(codeString))
+ return new Enumeration(this, ClaimStatus.DRAFT);
+ if ("entered-in-error".equals(codeString))
+ return new Enumeration(this, ClaimStatus.ENTEREDINERROR);
+ throw new FHIRException("Unknown ClaimStatus code '"+codeString+"'");
}
- public String toCode(ClaimType code) {
- if (code == ClaimType.INSTITUTIONAL)
- return "institutional";
- if (code == ClaimType.ORAL)
- return "oral";
- if (code == ClaimType.PHARMACY)
- return "pharmacy";
- if (code == ClaimType.PROFESSIONAL)
- return "professional";
- if (code == ClaimType.VISION)
- return "vision";
+ public String toCode(ClaimStatus code) {
+ if (code == ClaimStatus.ACTIVE)
+ return "active";
+ if (code == ClaimStatus.CANCELLED)
+ return "cancelled";
+ if (code == ClaimStatus.DRAFT)
+ return "draft";
+ if (code == ClaimStatus.ENTEREDINERROR)
+ return "entered-in-error";
return "?";
}
- public String toSystem(ClaimType code) {
+ public String toSystem(ClaimStatus code) {
return code.getSystem();
}
}
@@ -236,10 +220,10 @@ public class Claim extends DomainResource {
}
public String getSystem() {
switch (this) {
- case COMPLETE: return "http://hl7.org/fhir/claim-use-link";
- case PROPOSED: return "http://hl7.org/fhir/claim-use-link";
- case EXPLORATORY: return "http://hl7.org/fhir/claim-use-link";
- case OTHER: return "http://hl7.org/fhir/claim-use-link";
+ case COMPLETE: return "http://hl7.org/fhir/claim-use";
+ case PROPOSED: return "http://hl7.org/fhir/claim-use";
+ case EXPLORATORY: return "http://hl7.org/fhir/claim-use";
+ case OTHER: return "http://hl7.org/fhir/claim-use";
default: return "?";
}
}
@@ -315,21 +299,22 @@ public class Claim extends DomainResource {
/**
* Other claims which are related to this claim such as prior claim versions or for related services.
*/
- @Child(name = "claim", type = {Identifier.class, Claim.class}, order=1, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "claim", type = {Identifier.class, Claim.class}, order=1, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Reference to the related claim", formalDefinition="Other claims which are related to this claim such as prior claim versions or for related services." )
protected Type claim;
/**
* For example prior or umbrella.
*/
- @Child(name = "relationship", type = {Coding.class}, order=2, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "relationship", type = {Coding.class}, order=2, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="How the reference claim is related", formalDefinition="For example prior or umbrella." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/related-claim-relationship")
protected Coding relationship;
/**
* An alternate organizational reference to the case or file to which this particular claim pertains - eg Property/Casualy insurer claim # or Workers Compensation case # .
*/
- @Child(name = "reference", type = {Identifier.class}, order=3, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "reference", type = {Identifier.class}, order=3, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Related file or case reference", formalDefinition="An alternate organizational reference to the case or file to which this particular claim pertains - eg Property/Casualy insurer claim # or Workers Compensation case # ." )
protected Identifier reference;
@@ -562,21 +547,23 @@ public class Claim extends DomainResource {
/**
* Type of Party to be reimbursed: Subscriber, provider, other.
*/
- @Child(name = "type", type = {Coding.class}, order=1, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "type", type = {Coding.class}, order=1, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="Type of party: Subscriber, Provider, other", formalDefinition="Type of Party to be reimbursed: Subscriber, provider, other." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/payeetype")
protected Coding type;
/**
* organization | patient | practitioner | relatedperson.
*/
- @Child(name = "resourceType", type = {Coding.class}, order=2, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "resourceType", type = {Coding.class}, order=2, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="organization | patient | practitioner | relatedperson", formalDefinition="organization | patient | practitioner | relatedperson." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/resource-type")
protected Coding resourceType;
/**
* Party to be reimbursed: Subscriber, provider, other.
*/
- @Child(name = "party", type = {Identifier.class, Practitioner.class, Organization.class, Patient.class, RelatedPerson.class}, order=3, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "party", type = {Identifier.class, Practitioner.class, Organization.class, Patient.class, RelatedPerson.class}, order=3, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Party to receive the payable", formalDefinition="Party to be reimbursed: Subscriber, provider, other." )
protected Type party;
@@ -813,58 +800,52 @@ public class Claim extends DomainResource {
}
@Block()
- public static class InformationComponent extends BackboneElement implements IBaseBackboneElement {
+ public static class SpecialConditionComponent extends BackboneElement implements IBaseBackboneElement {
/**
* The general class of the information supplied: information; exception; accident, employment; onset, etc.
*/
- @Child(name = "category", type = {Coding.class}, order=1, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "category", type = {Coding.class}, order=1, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="Category of information", formalDefinition="The general class of the information supplied: information; exception; accident, employment; onset, etc." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/claim-informationcategory")
protected Coding category;
/**
* System and code pertaining to the specific information regarding special conditions relating to the setting, treatment or patient for which care is sought which may influence the adjudication.
*/
- @Child(name = "code", type = {Coding.class}, order=2, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "code", type = {Coding.class}, order=2, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Type of information", formalDefinition="System and code pertaining to the specific information regarding special conditions relating to the setting, treatment or patient for which care is sought which may influence the adjudication." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/claim-exception")
protected Coding code;
- /**
- * A reason code which supports the reporting of the information code or provides further details for the information code.
- */
- @Child(name = "reason", type = {Coding.class}, order=3, min=0, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Supporting Reason", formalDefinition="A reason code which supports the reporting of the information code or provides further details for the information code." )
- protected Coding reason;
-
/**
* The date when or period to which this information refers.
*/
- @Child(name = "timing", type = {DateType.class, Period.class}, order=4, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "timing", type = {DateType.class, Period.class}, order=3, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="When it occurred", formalDefinition="The date when or period to which this information refers." )
protected Type timing;
/**
* Additional data.
*/
- @Child(name = "value", type = {IntegerType.class, PositiveIntType.class, StringType.class, Address.class, Coding.class, Identifier.class, Quantity.class, Location.class}, order=5, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "value", type = {StringType.class, Quantity.class}, order=4, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Additional Data", formalDefinition="Additional data." )
protected Type value;
- private static final long serialVersionUID = 1767888500L;
+ private static final long serialVersionUID = 1771573412L;
/**
* Constructor
*/
- public InformationComponent() {
+ public SpecialConditionComponent() {
super();
}
/**
* Constructor
*/
- public InformationComponent(Coding category, Coding code) {
+ public SpecialConditionComponent(Coding category) {
super();
this.category = category;
- this.code = code;
}
/**
@@ -873,7 +854,7 @@ public class Claim extends DomainResource {
public Coding getCategory() {
if (this.category == null)
if (Configuration.errorOnAutoCreate())
- throw new Error("Attempt to auto-create InformationComponent.category");
+ throw new Error("Attempt to auto-create SpecialConditionComponent.category");
else if (Configuration.doAutoCreate())
this.category = new Coding(); // cc
return this.category;
@@ -886,7 +867,7 @@ public class Claim extends DomainResource {
/**
* @param value {@link #category} (The general class of the information supplied: information; exception; accident, employment; onset, etc.)
*/
- public InformationComponent setCategory(Coding value) {
+ public SpecialConditionComponent setCategory(Coding value) {
this.category = value;
return this;
}
@@ -897,7 +878,7 @@ public class Claim extends DomainResource {
public Coding getCode() {
if (this.code == null)
if (Configuration.errorOnAutoCreate())
- throw new Error("Attempt to auto-create InformationComponent.code");
+ throw new Error("Attempt to auto-create SpecialConditionComponent.code");
else if (Configuration.doAutoCreate())
this.code = new Coding(); // cc
return this.code;
@@ -910,35 +891,11 @@ public class Claim extends DomainResource {
/**
* @param value {@link #code} (System and code pertaining to the specific information regarding special conditions relating to the setting, treatment or patient for which care is sought which may influence the adjudication.)
*/
- public InformationComponent setCode(Coding value) {
+ public SpecialConditionComponent setCode(Coding value) {
this.code = value;
return this;
}
- /**
- * @return {@link #reason} (A reason code which supports the reporting of the information code or provides further details for the information code.)
- */
- public Coding getReason() {
- if (this.reason == null)
- if (Configuration.errorOnAutoCreate())
- throw new Error("Attempt to auto-create InformationComponent.reason");
- else if (Configuration.doAutoCreate())
- this.reason = new Coding(); // cc
- return this.reason;
- }
-
- public boolean hasReason() {
- return this.reason != null && !this.reason.isEmpty();
- }
-
- /**
- * @param value {@link #reason} (A reason code which supports the reporting of the information code or provides further details for the information code.)
- */
- public InformationComponent setReason(Coding value) {
- this.reason = value;
- return this;
- }
-
/**
* @return {@link #timing} (The date when or period to which this information refers.)
*/
@@ -979,7 +936,7 @@ public class Claim extends DomainResource {
/**
* @param value {@link #timing} (The date when or period to which this information refers.)
*/
- public InformationComponent setTiming(Type value) {
+ public SpecialConditionComponent setTiming(Type value) {
this.timing = value;
return this;
}
@@ -991,32 +948,6 @@ public class Claim extends DomainResource {
return this.value;
}
- /**
- * @return {@link #value} (Additional data.)
- */
- public IntegerType getValueIntegerType() throws FHIRException {
- if (!(this.value instanceof IntegerType))
- throw new FHIRException("Type mismatch: the type IntegerType was expected, but "+this.value.getClass().getName()+" was encountered");
- return (IntegerType) this.value;
- }
-
- public boolean hasValueIntegerType() {
- return this.value instanceof IntegerType;
- }
-
- /**
- * @return {@link #value} (Additional data.)
- */
- public PositiveIntType getValuePositiveIntType() throws FHIRException {
- if (!(this.value instanceof PositiveIntType))
- throw new FHIRException("Type mismatch: the type PositiveIntType was expected, but "+this.value.getClass().getName()+" was encountered");
- return (PositiveIntType) this.value;
- }
-
- public boolean hasValuePositiveIntType() {
- return this.value instanceof PositiveIntType;
- }
-
/**
* @return {@link #value} (Additional data.)
*/
@@ -1030,45 +961,6 @@ public class Claim extends DomainResource {
return this.value instanceof StringType;
}
- /**
- * @return {@link #value} (Additional data.)
- */
- public Address getValueAddress() throws FHIRException {
- if (!(this.value instanceof Address))
- throw new FHIRException("Type mismatch: the type Address was expected, but "+this.value.getClass().getName()+" was encountered");
- return (Address) this.value;
- }
-
- public boolean hasValueAddress() {
- return this.value instanceof Address;
- }
-
- /**
- * @return {@link #value} (Additional data.)
- */
- public Coding getValueCoding() throws FHIRException {
- if (!(this.value instanceof Coding))
- throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.value.getClass().getName()+" was encountered");
- return (Coding) this.value;
- }
-
- public boolean hasValueCoding() {
- return this.value instanceof Coding;
- }
-
- /**
- * @return {@link #value} (Additional data.)
- */
- public Identifier getValueIdentifier() throws FHIRException {
- if (!(this.value instanceof Identifier))
- throw new FHIRException("Type mismatch: the type Identifier was expected, but "+this.value.getClass().getName()+" was encountered");
- return (Identifier) this.value;
- }
-
- public boolean hasValueIdentifier() {
- return this.value instanceof Identifier;
- }
-
/**
* @return {@link #value} (Additional data.)
*/
@@ -1082,19 +974,6 @@ public class Claim extends DomainResource {
return this.value instanceof Quantity;
}
- /**
- * @return {@link #value} (Additional data.)
- */
- public Reference getValueReference() throws FHIRException {
- if (!(this.value instanceof Reference))
- throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.value.getClass().getName()+" was encountered");
- return (Reference) this.value;
- }
-
- public boolean hasValueReference() {
- return this.value instanceof Reference;
- }
-
public boolean hasValue() {
return this.value != null && !this.value.isEmpty();
}
@@ -1102,7 +981,7 @@ public class Claim extends DomainResource {
/**
* @param value {@link #value} (Additional data.)
*/
- public InformationComponent setValue(Type value) {
+ public SpecialConditionComponent setValue(Type value) {
this.value = value;
return this;
}
@@ -1111,9 +990,8 @@ public class Claim extends DomainResource {
super.listChildren(childrenList);
childrenList.add(new Property("category", "Coding", "The general class of the information supplied: information; exception; accident, employment; onset, etc.", 0, java.lang.Integer.MAX_VALUE, category));
childrenList.add(new Property("code", "Coding", "System and code pertaining to the specific information regarding special conditions relating to the setting, treatment or patient for which care is sought which may influence the adjudication.", 0, java.lang.Integer.MAX_VALUE, code));
- childrenList.add(new Property("reason", "Coding", "A reason code which supports the reporting of the information code or provides further details for the information code.", 0, java.lang.Integer.MAX_VALUE, reason));
childrenList.add(new Property("timing[x]", "date|Period", "The date when or period to which this information refers.", 0, java.lang.Integer.MAX_VALUE, timing));
- childrenList.add(new Property("value[x]", "integer|positiveInt|string|Address|Coding|Identifier|Quantity|Reference(Location)", "Additional data.", 0, java.lang.Integer.MAX_VALUE, value));
+ childrenList.add(new Property("value[x]", "string|Quantity", "Additional data.", 0, java.lang.Integer.MAX_VALUE, value));
}
@Override
@@ -1121,7 +999,6 @@ public class Claim extends DomainResource {
switch (hash) {
case 50511102: /*category*/ return this.category == null ? new Base[0] : new Base[] {this.category}; // Coding
case 3059181: /*code*/ return this.code == null ? new Base[0] : new Base[] {this.code}; // Coding
- case -934964668: /*reason*/ return this.reason == null ? new Base[0] : new Base[] {this.reason}; // Coding
case -873664438: /*timing*/ return this.timing == null ? new Base[0] : new Base[] {this.timing}; // Type
case 111972721: /*value*/ return this.value == null ? new Base[0] : new Base[] {this.value}; // Type
default: return super.getProperty(hash, name, checkValid);
@@ -1138,9 +1015,6 @@ public class Claim extends DomainResource {
case 3059181: // code
this.code = castToCoding(value); // Coding
break;
- case -934964668: // reason
- this.reason = castToCoding(value); // Coding
- break;
case -873664438: // timing
this.timing = (Type) value; // Type
break;
@@ -1158,8 +1032,6 @@ public class Claim extends DomainResource {
this.category = castToCoding(value); // Coding
else if (name.equals("code"))
this.code = castToCoding(value); // Coding
- else if (name.equals("reason"))
- this.reason = castToCoding(value); // Coding
else if (name.equals("timing[x]"))
this.timing = (Type) value; // Type
else if (name.equals("value[x]"))
@@ -1173,7 +1045,6 @@ public class Claim extends DomainResource {
switch (hash) {
case 50511102: return getCategory(); // Coding
case 3059181: return getCode(); // Coding
- case -934964668: return getReason(); // Coding
case 164632566: return getTiming(); // Type
case -1410166417: return getValue(); // Type
default: return super.makeProperty(hash, name);
@@ -1191,10 +1062,6 @@ public class Claim extends DomainResource {
this.code = new Coding();
return this.code;
}
- else if (name.equals("reason")) {
- this.reason = new Coding();
- return this.reason;
- }
else if (name.equals("timingDate")) {
this.timing = new DateType();
return this.timing;
@@ -1203,48 +1070,23 @@ public class Claim extends DomainResource {
this.timing = new Period();
return this.timing;
}
- else if (name.equals("valueInteger")) {
- this.value = new IntegerType();
- return this.value;
- }
- else if (name.equals("valuePositiveInt")) {
- this.value = new PositiveIntType();
- return this.value;
- }
else if (name.equals("valueString")) {
this.value = new StringType();
return this.value;
}
- else if (name.equals("valueAddress")) {
- this.value = new Address();
- return this.value;
- }
- else if (name.equals("valueCoding")) {
- this.value = new Coding();
- return this.value;
- }
- else if (name.equals("valueIdentifier")) {
- this.value = new Identifier();
- return this.value;
- }
else if (name.equals("valueQuantity")) {
this.value = new Quantity();
return this.value;
}
- else if (name.equals("valueReference")) {
- this.value = new Reference();
- return this.value;
- }
else
return super.addChild(name);
}
- public InformationComponent copy() {
- InformationComponent dst = new InformationComponent();
+ public SpecialConditionComponent copy() {
+ SpecialConditionComponent dst = new SpecialConditionComponent();
copyValues(dst);
dst.category = category == null ? null : category.copy();
dst.code = code == null ? null : code.copy();
- dst.reason = reason == null ? null : reason.copy();
dst.timing = timing == null ? null : timing.copy();
dst.value = value == null ? null : value.copy();
return dst;
@@ -1254,26 +1096,26 @@ public class Claim extends DomainResource {
public boolean equalsDeep(Base other) {
if (!super.equalsDeep(other))
return false;
- if (!(other instanceof InformationComponent))
+ if (!(other instanceof SpecialConditionComponent))
return false;
- InformationComponent o = (InformationComponent) other;
- return compareDeep(category, o.category, true) && compareDeep(code, o.code, true) && compareDeep(reason, o.reason, true)
- && compareDeep(timing, o.timing, true) && compareDeep(value, o.value, true);
+ SpecialConditionComponent o = (SpecialConditionComponent) other;
+ return compareDeep(category, o.category, true) && compareDeep(code, o.code, true) && compareDeep(timing, o.timing, true)
+ && compareDeep(value, o.value, true);
}
@Override
public boolean equalsShallow(Base other) {
if (!super.equalsShallow(other))
return false;
- if (!(other instanceof InformationComponent))
+ if (!(other instanceof SpecialConditionComponent))
return false;
- InformationComponent o = (InformationComponent) other;
+ SpecialConditionComponent o = (SpecialConditionComponent) other;
return true;
}
public boolean isEmpty() {
- return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(category, code, reason, timing
- , value);
+ return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(category, code, timing, value
+ );
}
public String fhirType() {
@@ -1288,18 +1130,35 @@ public class Claim extends DomainResource {
/**
* Sequence of diagnosis which serves to order and provide a link.
*/
- @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="Number to covey order of diagnosis", formalDefinition="Sequence of diagnosis which serves to order and provide a link." )
protected PositiveIntType sequence;
/**
* The diagnosis.
*/
- @Child(name = "diagnosis", type = {Coding.class}, order=2, min=1, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Patient's list of diagnosis", formalDefinition="The diagnosis." )
+ @Child(name = "diagnosis", type = {Coding.class}, order=2, min=1, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Patient's diagnosis", formalDefinition="The diagnosis." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/icd-10")
protected Coding diagnosis;
- private static final long serialVersionUID = -795010186L;
+ /**
+ * The type of the Diagnosis, for example: admitting,.
+ */
+ @Child(name = "type", type = {Coding.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="Type of Diagnosis", formalDefinition="The type of the Diagnosis, for example: admitting,." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/ex-diagnosistype")
+ protected List type;
+
+ /**
+ * The Diagnosis Related Group (DRG) code based on the assigned grouping code system.
+ */
+ @Child(name = "drg", type = {Coding.class}, order=4, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Diagnosis Related Group", formalDefinition="The Diagnosis Related Group (DRG) code based on the assigned grouping code system." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/ex-diagnosisrelatedgroup")
+ protected Coding drg;
+
+ private static final long serialVersionUID = 135693095L;
/**
* Constructor
@@ -1386,10 +1245,89 @@ public class Claim extends DomainResource {
return this;
}
+ /**
+ * @return {@link #type} (The type of the Diagnosis, for example: admitting,.)
+ */
+ public List getType() {
+ if (this.type == null)
+ this.type = new ArrayList();
+ return this.type;
+ }
+
+ /**
+ * @return Returns a reference to this
for easy method chaining
+ */
+ public DiagnosisComponent setType(List theType) {
+ this.type = theType;
+ return this;
+ }
+
+ public boolean hasType() {
+ if (this.type == null)
+ return false;
+ for (Coding item : this.type)
+ if (!item.isEmpty())
+ return true;
+ return false;
+ }
+
+ public Coding addType() { //3
+ Coding t = new Coding();
+ if (this.type == null)
+ this.type = new ArrayList();
+ this.type.add(t);
+ return t;
+ }
+
+ public DiagnosisComponent addType(Coding t) { //3
+ if (t == null)
+ return this;
+ if (this.type == null)
+ this.type = new ArrayList();
+ this.type.add(t);
+ return this;
+ }
+
+ /**
+ * @return The first repetition of repeating field {@link #type}, creating it if it does not already exist
+ */
+ public Coding getTypeFirstRep() {
+ if (getType().isEmpty()) {
+ addType();
+ }
+ return getType().get(0);
+ }
+
+ /**
+ * @return {@link #drg} (The Diagnosis Related Group (DRG) code based on the assigned grouping code system.)
+ */
+ public Coding getDrg() {
+ if (this.drg == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create DiagnosisComponent.drg");
+ else if (Configuration.doAutoCreate())
+ this.drg = new Coding(); // cc
+ return this.drg;
+ }
+
+ public boolean hasDrg() {
+ return this.drg != null && !this.drg.isEmpty();
+ }
+
+ /**
+ * @param value {@link #drg} (The Diagnosis Related Group (DRG) code based on the assigned grouping code system.)
+ */
+ public DiagnosisComponent setDrg(Coding value) {
+ this.drg = value;
+ return this;
+ }
+
protected void listChildren(List childrenList) {
super.listChildren(childrenList);
childrenList.add(new Property("sequence", "positiveInt", "Sequence of diagnosis which serves to order and provide a link.", 0, java.lang.Integer.MAX_VALUE, sequence));
childrenList.add(new Property("diagnosis", "Coding", "The diagnosis.", 0, java.lang.Integer.MAX_VALUE, diagnosis));
+ childrenList.add(new Property("type", "Coding", "The type of the Diagnosis, for example: admitting,.", 0, java.lang.Integer.MAX_VALUE, type));
+ childrenList.add(new Property("drg", "Coding", "The Diagnosis Related Group (DRG) code based on the assigned grouping code system.", 0, java.lang.Integer.MAX_VALUE, drg));
}
@Override
@@ -1397,6 +1335,8 @@ public class Claim extends DomainResource {
switch (hash) {
case 1349547969: /*sequence*/ return this.sequence == null ? new Base[0] : new Base[] {this.sequence}; // PositiveIntType
case 1196993265: /*diagnosis*/ return this.diagnosis == null ? new Base[0] : new Base[] {this.diagnosis}; // Coding
+ case 3575610: /*type*/ return this.type == null ? new Base[0] : this.type.toArray(new Base[this.type.size()]); // Coding
+ case 99737: /*drg*/ return this.drg == null ? new Base[0] : new Base[] {this.drg}; // Coding
default: return super.getProperty(hash, name, checkValid);
}
@@ -1411,6 +1351,12 @@ public class Claim extends DomainResource {
case 1196993265: // diagnosis
this.diagnosis = castToCoding(value); // Coding
break;
+ case 3575610: // type
+ this.getType().add(castToCoding(value)); // Coding
+ break;
+ case 99737: // drg
+ this.drg = castToCoding(value); // Coding
+ break;
default: super.setProperty(hash, name, value);
}
@@ -1422,6 +1368,10 @@ public class Claim extends DomainResource {
this.sequence = castToPositiveInt(value); // PositiveIntType
else if (name.equals("diagnosis"))
this.diagnosis = castToCoding(value); // Coding
+ else if (name.equals("type"))
+ this.getType().add(castToCoding(value));
+ else if (name.equals("drg"))
+ this.drg = castToCoding(value); // Coding
else
super.setProperty(name, value);
}
@@ -1431,6 +1381,8 @@ public class Claim extends DomainResource {
switch (hash) {
case 1349547969: throw new FHIRException("Cannot make property sequence as it is not a complex type"); // PositiveIntType
case 1196993265: return getDiagnosis(); // Coding
+ case 3575610: return addType(); // Coding
+ case 99737: return getDrg(); // Coding
default: return super.makeProperty(hash, name);
}
@@ -1445,6 +1397,13 @@ public class Claim extends DomainResource {
this.diagnosis = new Coding();
return this.diagnosis;
}
+ else if (name.equals("type")) {
+ return addType();
+ }
+ else if (name.equals("drg")) {
+ this.drg = new Coding();
+ return this.drg;
+ }
else
return super.addChild(name);
}
@@ -1454,6 +1413,12 @@ public class Claim extends DomainResource {
copyValues(dst);
dst.sequence = sequence == null ? null : sequence.copy();
dst.diagnosis = diagnosis == null ? null : diagnosis.copy();
+ if (type != null) {
+ dst.type = new ArrayList();
+ for (Coding i : type)
+ dst.type.add(i.copy());
+ };
+ dst.drg = drg == null ? null : drg.copy();
return dst;
}
@@ -1464,7 +1429,8 @@ public class Claim extends DomainResource {
if (!(other instanceof DiagnosisComponent))
return false;
DiagnosisComponent o = (DiagnosisComponent) other;
- return compareDeep(sequence, o.sequence, true) && compareDeep(diagnosis, o.diagnosis, true);
+ return compareDeep(sequence, o.sequence, true) && compareDeep(diagnosis, o.diagnosis, true) && compareDeep(type, o.type, true)
+ && compareDeep(drg, o.drg, true);
}
@Override
@@ -1478,7 +1444,8 @@ public class Claim extends DomainResource {
}
public boolean isEmpty() {
- return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(sequence, diagnosis);
+ return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(sequence, diagnosis, type
+ , drg);
}
public String fhirType() {
@@ -1493,22 +1460,23 @@ public class Claim extends DomainResource {
/**
* Sequence of procedures which serves to order and provide a link.
*/
- @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="Procedure sequence for reference", formalDefinition="Sequence of procedures which serves to order and provide a link." )
protected PositiveIntType sequence;
/**
* Date and optionally time the procedure was performed .
*/
- @Child(name = "date", type = {DateTimeType.class}, order=2, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "date", type = {DateTimeType.class}, order=2, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="When the procedure was performed", formalDefinition="Date and optionally time the procedure was performed ." )
protected DateTimeType date;
/**
* The procedure code.
*/
- @Child(name = "procedure", type = {Coding.class, Procedure.class}, order=3, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "procedure", type = {Coding.class, Procedure.class}, order=3, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="Patient's list of procedures performed", formalDefinition="The procedure code." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/icd-10-procedures")
protected Type procedure;
private static final long serialVersionUID = 864307347L;
@@ -1793,35 +1761,42 @@ public class Claim extends DomainResource {
/**
* A service line item.
*/
- @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="Service instance identifier", formalDefinition="A service line item." )
protected PositiveIntType sequence;
/**
* The instance number of the Coverage which is the focus for adjudication. The Coverage against which the claim is to be adjudicated.
*/
- @Child(name = "focal", type = {BooleanType.class}, order=2, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "focal", type = {BooleanType.class}, order=2, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="Is the focal Coverage", formalDefinition="The instance number of the Coverage which is the focus for adjudication. The Coverage against which the claim is to be adjudicated." )
protected BooleanType focal;
/**
* Reference to the program or plan identification, underwriter or payor.
*/
- @Child(name = "coverage", type = {Identifier.class, Coverage.class}, order=3, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "coverage", type = {Identifier.class, Coverage.class}, order=3, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="Insurance information", formalDefinition="Reference to the program or plan identification, underwriter or payor." )
protected Type coverage;
+ /**
+ * The contract number of a business agreement which describes the terms and conditions.
+ */
+ @Child(name = "businessArrangement", type = {StringType.class}, order=4, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Business agreement", formalDefinition="The contract number of a business agreement which describes the terms and conditions." )
+ protected StringType businessArrangement;
+
/**
* A list of references from the Insurer to which these services pertain.
*/
- @Child(name = "preAuthRef", type = {StringType.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "preAuthRef", type = {StringType.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Pre-Authorization/Determination Reference", formalDefinition="A list of references from the Insurer to which these services pertain." )
protected List preAuthRef;
/**
* The Coverages adjudication details.
*/
- @Child(name = "claimResponse", type = {ClaimResponse.class}, order=5, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "claimResponse", type = {ClaimResponse.class}, order=6, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Adjudication results", formalDefinition="The Coverages adjudication details." )
protected Reference claimResponse;
@@ -1833,11 +1808,12 @@ public class Claim extends DomainResource {
/**
* The style (standard) and version of the original material which was converted into this resource.
*/
- @Child(name = "originalRuleset", type = {Coding.class}, order=6, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "originalRuleset", type = {Coding.class}, order=7, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Original version", formalDefinition="The style (standard) and version of the original material which was converted into this resource." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/ruleset")
protected Coding originalRuleset;
- private static final long serialVersionUID = 1621849051L;
+ private static final long serialVersionUID = 2031704818L;
/**
* Constructor
@@ -1991,6 +1967,55 @@ public class Claim extends DomainResource {
return this;
}
+ /**
+ * @return {@link #businessArrangement} (The contract number of a business agreement which describes the terms and conditions.). This is the underlying object with id, value and extensions. The accessor "getBusinessArrangement" gives direct access to the value
+ */
+ public StringType getBusinessArrangementElement() {
+ if (this.businessArrangement == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create CoverageComponent.businessArrangement");
+ else if (Configuration.doAutoCreate())
+ this.businessArrangement = new StringType(); // bb
+ return this.businessArrangement;
+ }
+
+ public boolean hasBusinessArrangementElement() {
+ return this.businessArrangement != null && !this.businessArrangement.isEmpty();
+ }
+
+ public boolean hasBusinessArrangement() {
+ return this.businessArrangement != null && !this.businessArrangement.isEmpty();
+ }
+
+ /**
+ * @param value {@link #businessArrangement} (The contract number of a business agreement which describes the terms and conditions.). This is the underlying object with id, value and extensions. The accessor "getBusinessArrangement" gives direct access to the value
+ */
+ public CoverageComponent setBusinessArrangementElement(StringType value) {
+ this.businessArrangement = value;
+ return this;
+ }
+
+ /**
+ * @return The contract number of a business agreement which describes the terms and conditions.
+ */
+ public String getBusinessArrangement() {
+ return this.businessArrangement == null ? null : this.businessArrangement.getValue();
+ }
+
+ /**
+ * @param value The contract number of a business agreement which describes the terms and conditions.
+ */
+ public CoverageComponent setBusinessArrangement(String value) {
+ if (Utilities.noString(value))
+ this.businessArrangement = null;
+ else {
+ if (this.businessArrangement == null)
+ this.businessArrangement = new StringType();
+ this.businessArrangement.setValue(value);
+ }
+ return this;
+ }
+
/**
* @return {@link #preAuthRef} (A list of references from the Insurer to which these services pertain.)
*/
@@ -2125,6 +2150,7 @@ public class Claim extends DomainResource {
childrenList.add(new Property("sequence", "positiveInt", "A service line item.", 0, java.lang.Integer.MAX_VALUE, sequence));
childrenList.add(new Property("focal", "boolean", "The instance number of the Coverage which is the focus for adjudication. The Coverage against which the claim is to be adjudicated.", 0, java.lang.Integer.MAX_VALUE, focal));
childrenList.add(new Property("coverage[x]", "Identifier|Reference(Coverage)", "Reference to the program or plan identification, underwriter or payor.", 0, java.lang.Integer.MAX_VALUE, coverage));
+ childrenList.add(new Property("businessArrangement", "string", "The contract number of a business agreement which describes the terms and conditions.", 0, java.lang.Integer.MAX_VALUE, businessArrangement));
childrenList.add(new Property("preAuthRef", "string", "A list of references from the Insurer to which these services pertain.", 0, java.lang.Integer.MAX_VALUE, preAuthRef));
childrenList.add(new Property("claimResponse", "Reference(ClaimResponse)", "The Coverages adjudication details.", 0, java.lang.Integer.MAX_VALUE, claimResponse));
childrenList.add(new Property("originalRuleset", "Coding", "The style (standard) and version of the original material which was converted into this resource.", 0, java.lang.Integer.MAX_VALUE, originalRuleset));
@@ -2136,6 +2162,7 @@ public class Claim extends DomainResource {
case 1349547969: /*sequence*/ return this.sequence == null ? new Base[0] : new Base[] {this.sequence}; // PositiveIntType
case 97604197: /*focal*/ return this.focal == null ? new Base[0] : new Base[] {this.focal}; // BooleanType
case -351767064: /*coverage*/ return this.coverage == null ? new Base[0] : new Base[] {this.coverage}; // Type
+ case 259920682: /*businessArrangement*/ return this.businessArrangement == null ? new Base[0] : new Base[] {this.businessArrangement}; // StringType
case 522246568: /*preAuthRef*/ return this.preAuthRef == null ? new Base[0] : this.preAuthRef.toArray(new Base[this.preAuthRef.size()]); // StringType
case 689513629: /*claimResponse*/ return this.claimResponse == null ? new Base[0] : new Base[] {this.claimResponse}; // Reference
case 1089373397: /*originalRuleset*/ return this.originalRuleset == null ? new Base[0] : new Base[] {this.originalRuleset}; // Coding
@@ -2156,6 +2183,9 @@ public class Claim extends DomainResource {
case -351767064: // coverage
this.coverage = (Type) value; // Type
break;
+ case 259920682: // businessArrangement
+ this.businessArrangement = castToString(value); // StringType
+ break;
case 522246568: // preAuthRef
this.getPreAuthRef().add(castToString(value)); // StringType
break;
@@ -2178,6 +2208,8 @@ public class Claim extends DomainResource {
this.focal = castToBoolean(value); // BooleanType
else if (name.equals("coverage[x]"))
this.coverage = (Type) value; // Type
+ else if (name.equals("businessArrangement"))
+ this.businessArrangement = castToString(value); // StringType
else if (name.equals("preAuthRef"))
this.getPreAuthRef().add(castToString(value));
else if (name.equals("claimResponse"))
@@ -2194,6 +2226,7 @@ public class Claim extends DomainResource {
case 1349547969: throw new FHIRException("Cannot make property sequence as it is not a complex type"); // PositiveIntType
case 97604197: throw new FHIRException("Cannot make property focal as it is not a complex type"); // BooleanType
case 227689880: return getCoverage(); // Type
+ case 259920682: throw new FHIRException("Cannot make property businessArrangement as it is not a complex type"); // StringType
case 522246568: throw new FHIRException("Cannot make property preAuthRef as it is not a complex type"); // StringType
case 689513629: return getClaimResponse(); // Reference
case 1089373397: return getOriginalRuleset(); // Coding
@@ -2218,6 +2251,9 @@ public class Claim extends DomainResource {
this.coverage = new Reference();
return this.coverage;
}
+ else if (name.equals("businessArrangement")) {
+ throw new FHIRException("Cannot call addChild on a primitive type Claim.businessArrangement");
+ }
else if (name.equals("preAuthRef")) {
throw new FHIRException("Cannot call addChild on a primitive type Claim.preAuthRef");
}
@@ -2239,6 +2275,7 @@ public class Claim extends DomainResource {
dst.sequence = sequence == null ? null : sequence.copy();
dst.focal = focal == null ? null : focal.copy();
dst.coverage = coverage == null ? null : coverage.copy();
+ dst.businessArrangement = businessArrangement == null ? null : businessArrangement.copy();
if (preAuthRef != null) {
dst.preAuthRef = new ArrayList();
for (StringType i : preAuthRef)
@@ -2257,8 +2294,9 @@ public class Claim extends DomainResource {
return false;
CoverageComponent o = (CoverageComponent) other;
return compareDeep(sequence, o.sequence, true) && compareDeep(focal, o.focal, true) && compareDeep(coverage, o.coverage, true)
- && compareDeep(preAuthRef, o.preAuthRef, true) && compareDeep(claimResponse, o.claimResponse, true)
- && compareDeep(originalRuleset, o.originalRuleset, true);
+ && compareDeep(businessArrangement, o.businessArrangement, true) && compareDeep(preAuthRef, o.preAuthRef, true)
+ && compareDeep(claimResponse, o.claimResponse, true) && compareDeep(originalRuleset, o.originalRuleset, true)
+ ;
}
@Override
@@ -2268,13 +2306,13 @@ public class Claim extends DomainResource {
if (!(other instanceof CoverageComponent))
return false;
CoverageComponent o = (CoverageComponent) other;
- return compareValues(sequence, o.sequence, true) && compareValues(focal, o.focal, true) && compareValues(preAuthRef, o.preAuthRef, true)
- ;
+ return compareValues(sequence, o.sequence, true) && compareValues(focal, o.focal, true) && compareValues(businessArrangement, o.businessArrangement, true)
+ && compareValues(preAuthRef, o.preAuthRef, true);
}
public boolean isEmpty() {
return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(sequence, focal, coverage
- , preAuthRef, claimResponse, originalRuleset);
+ , businessArrangement, preAuthRef, claimResponse, originalRuleset);
}
public String fhirType() {
@@ -2282,6 +2320,281 @@ public class Claim extends DomainResource {
}
+ }
+
+ @Block()
+ public static class AccidentComponent extends BackboneElement implements IBaseBackboneElement {
+ /**
+ * Date of an accident which these services are addressing.
+ */
+ @Child(name = "date", type = {DateType.class}, order=1, min=1, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="When the accident occurred\nsee information codes\nsee information codes", formalDefinition="Date of an accident which these services are addressing." )
+ protected DateType date;
+
+ /**
+ * Type of accident: work, auto, etc.
+ */
+ @Child(name = "type", type = {Coding.class}, order=2, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="The nature of the accident", formalDefinition="Type of accident: work, auto, etc." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/v3-ActIncidentCode")
+ protected Coding type;
+
+ /**
+ * Accident Place.
+ */
+ @Child(name = "location", type = {Address.class, Location.class}, order=3, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Accident Place", formalDefinition="Accident Place." )
+ protected Type location;
+
+ private static final long serialVersionUID = -242365747L;
+
+ /**
+ * Constructor
+ */
+ public AccidentComponent() {
+ super();
+ }
+
+ /**
+ * Constructor
+ */
+ public AccidentComponent(DateType date) {
+ super();
+ this.date = date;
+ }
+
+ /**
+ * @return {@link #date} (Date of an accident which these services are addressing.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
+ */
+ public DateType getDateElement() {
+ if (this.date == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create AccidentComponent.date");
+ else if (Configuration.doAutoCreate())
+ this.date = new DateType(); // bb
+ return this.date;
+ }
+
+ public boolean hasDateElement() {
+ return this.date != null && !this.date.isEmpty();
+ }
+
+ public boolean hasDate() {
+ return this.date != null && !this.date.isEmpty();
+ }
+
+ /**
+ * @param value {@link #date} (Date of an accident which these services are addressing.). This is the underlying object with id, value and extensions. The accessor "getDate" gives direct access to the value
+ */
+ public AccidentComponent setDateElement(DateType value) {
+ this.date = value;
+ return this;
+ }
+
+ /**
+ * @return Date of an accident which these services are addressing.
+ */
+ public Date getDate() {
+ return this.date == null ? null : this.date.getValue();
+ }
+
+ /**
+ * @param value Date of an accident which these services are addressing.
+ */
+ public AccidentComponent setDate(Date value) {
+ if (this.date == null)
+ this.date = new DateType();
+ this.date.setValue(value);
+ return this;
+ }
+
+ /**
+ * @return {@link #type} (Type of accident: work, auto, etc.)
+ */
+ public Coding getType() {
+ if (this.type == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create AccidentComponent.type");
+ else if (Configuration.doAutoCreate())
+ this.type = new Coding(); // cc
+ return this.type;
+ }
+
+ public boolean hasType() {
+ return this.type != null && !this.type.isEmpty();
+ }
+
+ /**
+ * @param value {@link #type} (Type of accident: work, auto, etc.)
+ */
+ public AccidentComponent setType(Coding value) {
+ this.type = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #location} (Accident Place.)
+ */
+ public Type getLocation() {
+ return this.location;
+ }
+
+ /**
+ * @return {@link #location} (Accident Place.)
+ */
+ public Address getLocationAddress() throws FHIRException {
+ if (!(this.location instanceof Address))
+ throw new FHIRException("Type mismatch: the type Address was expected, but "+this.location.getClass().getName()+" was encountered");
+ return (Address) this.location;
+ }
+
+ public boolean hasLocationAddress() {
+ return this.location instanceof Address;
+ }
+
+ /**
+ * @return {@link #location} (Accident Place.)
+ */
+ public Reference getLocationReference() throws FHIRException {
+ if (!(this.location instanceof Reference))
+ throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.location.getClass().getName()+" was encountered");
+ return (Reference) this.location;
+ }
+
+ public boolean hasLocationReference() {
+ return this.location instanceof Reference;
+ }
+
+ public boolean hasLocation() {
+ return this.location != null && !this.location.isEmpty();
+ }
+
+ /**
+ * @param value {@link #location} (Accident Place.)
+ */
+ public AccidentComponent setLocation(Type value) {
+ this.location = value;
+ return this;
+ }
+
+ protected void listChildren(List childrenList) {
+ super.listChildren(childrenList);
+ childrenList.add(new Property("date", "date", "Date of an accident which these services are addressing.", 0, java.lang.Integer.MAX_VALUE, date));
+ childrenList.add(new Property("type", "Coding", "Type of accident: work, auto, etc.", 0, java.lang.Integer.MAX_VALUE, type));
+ childrenList.add(new Property("location[x]", "Address|Reference(Location)", "Accident Place.", 0, java.lang.Integer.MAX_VALUE, location));
+ }
+
+ @Override
+ public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
+ switch (hash) {
+ case 3076014: /*date*/ return this.date == null ? new Base[0] : new Base[] {this.date}; // DateType
+ case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Coding
+ case 1901043637: /*location*/ return this.location == null ? new Base[0] : new Base[] {this.location}; // Type
+ default: return super.getProperty(hash, name, checkValid);
+ }
+
+ }
+
+ @Override
+ public void setProperty(int hash, String name, Base value) throws FHIRException {
+ switch (hash) {
+ case 3076014: // date
+ this.date = castToDate(value); // DateType
+ break;
+ case 3575610: // type
+ this.type = castToCoding(value); // Coding
+ break;
+ case 1901043637: // location
+ this.location = (Type) value; // Type
+ break;
+ default: super.setProperty(hash, name, value);
+ }
+
+ }
+
+ @Override
+ public void setProperty(String name, Base value) throws FHIRException {
+ if (name.equals("date"))
+ this.date = castToDate(value); // DateType
+ else if (name.equals("type"))
+ this.type = castToCoding(value); // Coding
+ else if (name.equals("location[x]"))
+ this.location = (Type) value; // Type
+ else
+ super.setProperty(name, value);
+ }
+
+ @Override
+ public Base makeProperty(int hash, String name) throws FHIRException {
+ switch (hash) {
+ case 3076014: throw new FHIRException("Cannot make property date as it is not a complex type"); // DateType
+ case 3575610: return getType(); // Coding
+ case 552316075: return getLocation(); // Type
+ default: return super.makeProperty(hash, name);
+ }
+
+ }
+
+ @Override
+ public Base addChild(String name) throws FHIRException {
+ if (name.equals("date")) {
+ throw new FHIRException("Cannot call addChild on a primitive type Claim.date");
+ }
+ else if (name.equals("type")) {
+ this.type = new Coding();
+ return this.type;
+ }
+ else if (name.equals("locationAddress")) {
+ this.location = new Address();
+ return this.location;
+ }
+ else if (name.equals("locationReference")) {
+ this.location = new Reference();
+ return this.location;
+ }
+ else
+ return super.addChild(name);
+ }
+
+ public AccidentComponent copy() {
+ AccidentComponent dst = new AccidentComponent();
+ copyValues(dst);
+ dst.date = date == null ? null : date.copy();
+ dst.type = type == null ? null : type.copy();
+ dst.location = location == null ? null : location.copy();
+ return dst;
+ }
+
+ @Override
+ public boolean equalsDeep(Base other) {
+ if (!super.equalsDeep(other))
+ return false;
+ if (!(other instanceof AccidentComponent))
+ return false;
+ AccidentComponent o = (AccidentComponent) other;
+ return compareDeep(date, o.date, true) && compareDeep(type, o.type, true) && compareDeep(location, o.location, true)
+ ;
+ }
+
+ @Override
+ public boolean equalsShallow(Base other) {
+ if (!super.equalsShallow(other))
+ return false;
+ if (!(other instanceof AccidentComponent))
+ return false;
+ AccidentComponent o = (AccidentComponent) other;
+ return compareValues(date, o.date, true);
+ }
+
+ public boolean isEmpty() {
+ return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(date, type, location);
+ }
+
+ public String fhirType() {
+ return "Claim.accident";
+
+ }
+
}
@Block()
@@ -2289,112 +2602,118 @@ public class Claim extends DomainResource {
/**
* A service line number.
*/
- @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="Service instance", formalDefinition="A service line number." )
protected PositiveIntType sequence;
- /**
- * The type of product or service.
- */
- @Child(name = "type", type = {Coding.class}, order=2, min=1, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Group or type of product or service", formalDefinition="The type of product or service." )
- protected Coding type;
-
/**
* The members of the team who provided the overall service as well as their role and whether responsible and qualifications.
*/
- @Child(name = "careTeam", type = {}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "careTeam", type = {}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="", formalDefinition="The members of the team who provided the overall service as well as their role and whether responsible and qualifications." )
protected List careTeam;
/**
* Diagnosis applicable for this service or product line.
*/
- @Child(name = "diagnosisLinkId", type = {PositiveIntType.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "diagnosisLinkId", type = {PositiveIntType.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Applicable diagnoses", formalDefinition="Diagnosis applicable for this service or product line." )
protected List diagnosisLinkId;
/**
- * If a grouping item then 'GROUP' otherwise it is a node therefore a code to indicate the Professional Service or Product supplied.
+ * The type of reveneu or cost center providing the product and/or service.
*/
- @Child(name = "service", type = {Coding.class}, order=5, min=1, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Item Code", formalDefinition="If a grouping item then 'GROUP' otherwise it is a node therefore a code to indicate the Professional Service or Product supplied." )
+ @Child(name = "revenue", type = {Coding.class}, order=4, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Revenue or cost center code", formalDefinition="The type of reveneu or cost center providing the product and/or service." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/ex-revenue-center")
+ protected Coding revenue;
+
+ /**
+ * Health Care Service Type Codes to identify the classification of service or benefits.
+ */
+ @Child(name = "category", type = {Coding.class}, order=5, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Type of service or product", formalDefinition="Health Care Service Type Codes to identify the classification of service or benefits." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/benefit-subcategory")
+ protected Coding category;
+
+ /**
+ * If this is an actual service or product line, ie. not a Group, then use code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI). If a grouping item then use a group code to indicate the type of thing being grouped eg. 'glasses' or 'compound'.
+ */
+ @Child(name = "service", type = {Coding.class}, order=6, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Billing Code", formalDefinition="If this is an actual service or product line, ie. not a Group, then use code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI). If a grouping item then use a group code to indicate the type of thing being grouped eg. 'glasses' or 'compound'." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/service-uscls")
protected Coding service;
/**
- * Unusual circumstances which may influence adjudication.
+ * Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours.
*/
- @Child(name = "serviceModifier", type = {Coding.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
- @Description(shortDefinition="Service/Product modifiers", formalDefinition="Unusual circumstances which may influence adjudication." )
- protected List serviceModifier;
-
- /**
- * Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or an appliance was lost or stolen.
- */
- @Child(name = "modifier", type = {Coding.class}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
- @Description(shortDefinition="Service/Product billing modifiers", formalDefinition="Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or an appliance was lost or stolen." )
+ @Child(name = "modifier", type = {Coding.class}, order=7, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="Service/Product billing modifiers", formalDefinition="Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/claim-modifiers")
protected List modifier;
/**
* For programs which require reason codes for the inclusion or covering of this billed item under the program or sub-program.
*/
- @Child(name = "programCode", type = {Coding.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "programCode", type = {Coding.class}, order=8, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Program specific reason for item inclusion", formalDefinition="For programs which require reason codes for the inclusion or covering of this billed item under the program or sub-program." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/ex-program-code")
protected List programCode;
/**
* The date or dates when the enclosed suite of services were performed or completed.
*/
- @Child(name = "serviced", type = {DateType.class, Period.class}, order=9, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "serviced", type = {DateType.class, Period.class}, order=9, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Date or dates of Service", formalDefinition="The date or dates when the enclosed suite of services were performed or completed." )
protected Type serviced;
/**
* Where the service was provided.
*/
- @Child(name = "serviceLocation", type = {Coding.class, Address.class, Location.class}, order=10, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "location", type = {Coding.class, Address.class, Location.class}, order=10, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Place of service", formalDefinition="Where the service was provided." )
- protected Type serviceLocation;
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/service-place")
+ protected Type location;
/**
* The number of repetitions of a service or product.
*/
- @Child(name = "quantity", type = {SimpleQuantity.class}, order=11, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "quantity", type = {SimpleQuantity.class}, order=11, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Count of Products or Services", formalDefinition="The number of repetitions of a service or product." )
protected SimpleQuantity quantity;
/**
* If the item is a node then this is the fee for the product or service, otherwise this is the total of the fees for the children of the group.
*/
- @Child(name = "unitPrice", type = {Money.class}, order=12, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "unitPrice", type = {Money.class}, order=12, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Fee, charge or cost per point", formalDefinition="If the item is a node then this is the fee for the product or service, otherwise this is the total of the fees for the children of the group." )
protected Money unitPrice;
/**
* A real number that represents a multiplier used in determining the overall value of services delivered and/or goods received. The concept of a Factor allows for a discount or surcharge multiplier to be applied to a monetary amount.
*/
- @Child(name = "factor", type = {DecimalType.class}, order=13, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "factor", type = {DecimalType.class}, order=13, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Price scaling factor", formalDefinition="A real number that represents a multiplier used in determining the overall value of services delivered and/or goods received. The concept of a Factor allows for a discount or surcharge multiplier to be applied to a monetary amount." )
protected DecimalType factor;
/**
* An amount that expresses the weighting (based on difficulty, cost and/or resource intensiveness) associated with the good or service delivered. The concept of Points allows for assignment of point values for services and/or goods, such that a monetary amount can be assigned to each point.
*/
- @Child(name = "points", type = {DecimalType.class}, order=14, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "points", type = {DecimalType.class}, order=14, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Difficulty scaling factor", formalDefinition="An amount that expresses the weighting (based on difficulty, cost and/or resource intensiveness) associated with the good or service delivered. The concept of Points allows for assignment of point values for services and/or goods, such that a monetary amount can be assigned to each point." )
protected DecimalType points;
/**
* The quantity times the unit price for an addittional service or product or charge. For example, the formula: unit Quantity * unit Price (Cost per Point) * factor Number * points = net Amount. Quantity, factor and points are assumed to be 1 if not supplied.
*/
- @Child(name = "net", type = {Money.class}, order=15, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "net", type = {Money.class}, order=15, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Total item cost", formalDefinition="The quantity times the unit price for an addittional service or product or charge. For example, the formula: unit Quantity * unit Price (Cost per Point) * factor Number * points = net Amount. Quantity, factor and points are assumed to be 1 if not supplied." )
protected Money net;
/**
* List of Unique Device Identifiers associated with this line item.
*/
- @Child(name = "udi", type = {Device.class}, order=16, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "udi", type = {Device.class}, order=16, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Unique Device Identifier", formalDefinition="List of Unique Device Identifiers associated with this line item." )
protected List udi;
/**
@@ -2406,32 +2725,34 @@ public class Claim extends DomainResource {
/**
* Physical service site on the patient (limb, tooth, etc).
*/
- @Child(name = "bodySite", type = {Coding.class}, order=17, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "bodySite", type = {Coding.class}, order=17, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Service Location", formalDefinition="Physical service site on the patient (limb, tooth, etc)." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/tooth")
protected Coding bodySite;
/**
* A region or surface of the site, eg. limb region or tooth surface(s).
*/
- @Child(name = "subSite", type = {Coding.class}, order=18, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "subSite", type = {Coding.class}, order=18, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Service Sub-location", formalDefinition="A region or surface of the site, eg. limb region or tooth surface(s)." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/surface")
protected List subSite;
/**
* Second tier of goods and services.
*/
- @Child(name = "detail", type = {}, order=19, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "detail", type = {}, order=19, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Additional items", formalDefinition="Second tier of goods and services." )
protected List detail;
/**
* The materials and placement date of prior fixed prosthesis.
*/
- @Child(name = "prosthesis", type = {}, order=20, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "prosthesis", type = {}, order=20, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Prosthetic details", formalDefinition="The materials and placement date of prior fixed prosthesis." )
protected ProsthesisComponent prosthesis;
- private static final long serialVersionUID = 271205346L;
+ private static final long serialVersionUID = 749339585L;
/**
* Constructor
@@ -2443,11 +2764,9 @@ public class Claim extends DomainResource {
/**
* Constructor
*/
- public ItemComponent(PositiveIntType sequence, Coding type, Coding service) {
+ public ItemComponent(PositiveIntType sequence) {
super();
this.sequence = sequence;
- this.type = type;
- this.service = service;
}
/**
@@ -2495,30 +2814,6 @@ public class Claim extends DomainResource {
return this;
}
- /**
- * @return {@link #type} (The type of product or service.)
- */
- public Coding getType() {
- if (this.type == null)
- if (Configuration.errorOnAutoCreate())
- throw new Error("Attempt to auto-create ItemComponent.type");
- else if (Configuration.doAutoCreate())
- this.type = new Coding(); // cc
- return this.type;
- }
-
- public boolean hasType() {
- return this.type != null && !this.type.isEmpty();
- }
-
- /**
- * @param value {@link #type} (The type of product or service.)
- */
- public ItemComponent setType(Coding value) {
- this.type = value;
- return this;
- }
-
/**
* @return {@link #careTeam} (The members of the team who provided the overall service as well as their role and whether responsible and qualifications.)
*/
@@ -2634,7 +2929,55 @@ public class Claim extends DomainResource {
}
/**
- * @return {@link #service} (If a grouping item then 'GROUP' otherwise it is a node therefore a code to indicate the Professional Service or Product supplied.)
+ * @return {@link #revenue} (The type of reveneu or cost center providing the product and/or service.)
+ */
+ public Coding getRevenue() {
+ if (this.revenue == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ItemComponent.revenue");
+ else if (Configuration.doAutoCreate())
+ this.revenue = new Coding(); // cc
+ return this.revenue;
+ }
+
+ public boolean hasRevenue() {
+ return this.revenue != null && !this.revenue.isEmpty();
+ }
+
+ /**
+ * @param value {@link #revenue} (The type of reveneu or cost center providing the product and/or service.)
+ */
+ public ItemComponent setRevenue(Coding value) {
+ this.revenue = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #category} (Health Care Service Type Codes to identify the classification of service or benefits.)
+ */
+ public Coding getCategory() {
+ if (this.category == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create ItemComponent.category");
+ else if (Configuration.doAutoCreate())
+ this.category = new Coding(); // cc
+ return this.category;
+ }
+
+ public boolean hasCategory() {
+ return this.category != null && !this.category.isEmpty();
+ }
+
+ /**
+ * @param value {@link #category} (Health Care Service Type Codes to identify the classification of service or benefits.)
+ */
+ public ItemComponent setCategory(Coding value) {
+ this.category = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #service} (If this is an actual service or product line, ie. not a Group, then use code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI). If a grouping item then use a group code to indicate the type of thing being grouped eg. 'glasses' or 'compound'.)
*/
public Coding getService() {
if (this.service == null)
@@ -2650,7 +2993,7 @@ public class Claim extends DomainResource {
}
/**
- * @param value {@link #service} (If a grouping item then 'GROUP' otherwise it is a node therefore a code to indicate the Professional Service or Product supplied.)
+ * @param value {@link #service} (If this is an actual service or product line, ie. not a Group, then use code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI). If a grouping item then use a group code to indicate the type of thing being grouped eg. 'glasses' or 'compound'.)
*/
public ItemComponent setService(Coding value) {
this.service = value;
@@ -2658,60 +3001,7 @@ public class Claim extends DomainResource {
}
/**
- * @return {@link #serviceModifier} (Unusual circumstances which may influence adjudication.)
- */
- public List getServiceModifier() {
- if (this.serviceModifier == null)
- this.serviceModifier = new ArrayList();
- return this.serviceModifier;
- }
-
- /**
- * @return Returns a reference to this
for easy method chaining
- */
- public ItemComponent setServiceModifier(List theServiceModifier) {
- this.serviceModifier = theServiceModifier;
- return this;
- }
-
- public boolean hasServiceModifier() {
- if (this.serviceModifier == null)
- return false;
- for (Coding item : this.serviceModifier)
- if (!item.isEmpty())
- return true;
- return false;
- }
-
- public Coding addServiceModifier() { //3
- Coding t = new Coding();
- if (this.serviceModifier == null)
- this.serviceModifier = new ArrayList();
- this.serviceModifier.add(t);
- return t;
- }
-
- public ItemComponent addServiceModifier(Coding t) { //3
- if (t == null)
- return this;
- if (this.serviceModifier == null)
- this.serviceModifier = new ArrayList();
- this.serviceModifier.add(t);
- return this;
- }
-
- /**
- * @return The first repetition of repeating field {@link #serviceModifier}, creating it if it does not already exist
- */
- public Coding getServiceModifierFirstRep() {
- if (getServiceModifier().isEmpty()) {
- addServiceModifier();
- }
- return getServiceModifier().get(0);
- }
-
- /**
- * @return {@link #modifier} (Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or an appliance was lost or stolen.)
+ * @return {@link #modifier} (Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours.)
*/
public List getModifier() {
if (this.modifier == null)
@@ -2862,60 +3152,60 @@ public class Claim extends DomainResource {
}
/**
- * @return {@link #serviceLocation} (Where the service was provided.)
+ * @return {@link #location} (Where the service was provided.)
*/
- public Type getServiceLocation() {
- return this.serviceLocation;
+ public Type getLocation() {
+ return this.location;
}
/**
- * @return {@link #serviceLocation} (Where the service was provided.)
+ * @return {@link #location} (Where the service was provided.)
*/
- public Coding getServiceLocationCoding() throws FHIRException {
- if (!(this.serviceLocation instanceof Coding))
- throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.serviceLocation.getClass().getName()+" was encountered");
- return (Coding) this.serviceLocation;
+ public Coding getLocationCoding() throws FHIRException {
+ if (!(this.location instanceof Coding))
+ throw new FHIRException("Type mismatch: the type Coding was expected, but "+this.location.getClass().getName()+" was encountered");
+ return (Coding) this.location;
}
- public boolean hasServiceLocationCoding() {
- return this.serviceLocation instanceof Coding;
+ public boolean hasLocationCoding() {
+ return this.location instanceof Coding;
}
/**
- * @return {@link #serviceLocation} (Where the service was provided.)
+ * @return {@link #location} (Where the service was provided.)
*/
- public Address getServiceLocationAddress() throws FHIRException {
- if (!(this.serviceLocation instanceof Address))
- throw new FHIRException("Type mismatch: the type Address was expected, but "+this.serviceLocation.getClass().getName()+" was encountered");
- return (Address) this.serviceLocation;
+ public Address getLocationAddress() throws FHIRException {
+ if (!(this.location instanceof Address))
+ throw new FHIRException("Type mismatch: the type Address was expected, but "+this.location.getClass().getName()+" was encountered");
+ return (Address) this.location;
}
- public boolean hasServiceLocationAddress() {
- return this.serviceLocation instanceof Address;
+ public boolean hasLocationAddress() {
+ return this.location instanceof Address;
}
/**
- * @return {@link #serviceLocation} (Where the service was provided.)
+ * @return {@link #location} (Where the service was provided.)
*/
- public Reference getServiceLocationReference() throws FHIRException {
- if (!(this.serviceLocation instanceof Reference))
- throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.serviceLocation.getClass().getName()+" was encountered");
- return (Reference) this.serviceLocation;
+ public Reference getLocationReference() throws FHIRException {
+ if (!(this.location instanceof Reference))
+ throw new FHIRException("Type mismatch: the type Reference was expected, but "+this.location.getClass().getName()+" was encountered");
+ return (Reference) this.location;
}
- public boolean hasServiceLocationReference() {
- return this.serviceLocation instanceof Reference;
+ public boolean hasLocationReference() {
+ return this.location instanceof Reference;
}
- public boolean hasServiceLocation() {
- return this.serviceLocation != null && !this.serviceLocation.isEmpty();
+ public boolean hasLocation() {
+ return this.location != null && !this.location.isEmpty();
}
/**
- * @param value {@link #serviceLocation} (Where the service was provided.)
+ * @param value {@link #location} (Where the service was provided.)
*/
- public ItemComponent setServiceLocation(Type value) {
- this.serviceLocation = value;
+ public ItemComponent setLocation(Type value) {
+ this.location = value;
return this;
}
@@ -3357,15 +3647,15 @@ public class Claim extends DomainResource {
protected void listChildren(List childrenList) {
super.listChildren(childrenList);
childrenList.add(new Property("sequence", "positiveInt", "A service line number.", 0, java.lang.Integer.MAX_VALUE, sequence));
- childrenList.add(new Property("type", "Coding", "The type of product or service.", 0, java.lang.Integer.MAX_VALUE, type));
childrenList.add(new Property("careTeam", "", "The members of the team who provided the overall service as well as their role and whether responsible and qualifications.", 0, java.lang.Integer.MAX_VALUE, careTeam));
childrenList.add(new Property("diagnosisLinkId", "positiveInt", "Diagnosis applicable for this service or product line.", 0, java.lang.Integer.MAX_VALUE, diagnosisLinkId));
- childrenList.add(new Property("service", "Coding", "If a grouping item then 'GROUP' otherwise it is a node therefore a code to indicate the Professional Service or Product supplied.", 0, java.lang.Integer.MAX_VALUE, service));
- childrenList.add(new Property("serviceModifier", "Coding", "Unusual circumstances which may influence adjudication.", 0, java.lang.Integer.MAX_VALUE, serviceModifier));
- childrenList.add(new Property("modifier", "Coding", "Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or an appliance was lost or stolen.", 0, java.lang.Integer.MAX_VALUE, modifier));
+ childrenList.add(new Property("revenue", "Coding", "The type of reveneu or cost center providing the product and/or service.", 0, java.lang.Integer.MAX_VALUE, revenue));
+ childrenList.add(new Property("category", "Coding", "Health Care Service Type Codes to identify the classification of service or benefits.", 0, java.lang.Integer.MAX_VALUE, category));
+ childrenList.add(new Property("service", "Coding", "If this is an actual service or product line, ie. not a Group, then use code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI). If a grouping item then use a group code to indicate the type of thing being grouped eg. 'glasses' or 'compound'.", 0, java.lang.Integer.MAX_VALUE, service));
+ childrenList.add(new Property("modifier", "Coding", "Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours.", 0, java.lang.Integer.MAX_VALUE, modifier));
childrenList.add(new Property("programCode", "Coding", "For programs which require reason codes for the inclusion or covering of this billed item under the program or sub-program.", 0, java.lang.Integer.MAX_VALUE, programCode));
childrenList.add(new Property("serviced[x]", "date|Period", "The date or dates when the enclosed suite of services were performed or completed.", 0, java.lang.Integer.MAX_VALUE, serviced));
- childrenList.add(new Property("serviceLocation[x]", "Coding|Address|Reference(Location)", "Where the service was provided.", 0, java.lang.Integer.MAX_VALUE, serviceLocation));
+ childrenList.add(new Property("location[x]", "Coding|Address|Reference(Location)", "Where the service was provided.", 0, java.lang.Integer.MAX_VALUE, location));
childrenList.add(new Property("quantity", "SimpleQuantity", "The number of repetitions of a service or product.", 0, java.lang.Integer.MAX_VALUE, quantity));
childrenList.add(new Property("unitPrice", "Money", "If the item is a node then this is the fee for the product or service, otherwise this is the total of the fees for the children of the group.", 0, java.lang.Integer.MAX_VALUE, unitPrice));
childrenList.add(new Property("factor", "decimal", "A real number that represents a multiplier used in determining the overall value of services delivered and/or goods received. The concept of a Factor allows for a discount or surcharge multiplier to be applied to a monetary amount.", 0, java.lang.Integer.MAX_VALUE, factor));
@@ -3382,15 +3672,15 @@ public class Claim extends DomainResource {
public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
switch (hash) {
case 1349547969: /*sequence*/ return this.sequence == null ? new Base[0] : new Base[] {this.sequence}; // PositiveIntType
- case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Coding
case -7323378: /*careTeam*/ return this.careTeam == null ? new Base[0] : this.careTeam.toArray(new Base[this.careTeam.size()]); // CareTeamComponent
case -1659207418: /*diagnosisLinkId*/ return this.diagnosisLinkId == null ? new Base[0] : this.diagnosisLinkId.toArray(new Base[this.diagnosisLinkId.size()]); // PositiveIntType
+ case 1099842588: /*revenue*/ return this.revenue == null ? new Base[0] : new Base[] {this.revenue}; // Coding
+ case 50511102: /*category*/ return this.category == null ? new Base[0] : new Base[] {this.category}; // Coding
case 1984153269: /*service*/ return this.service == null ? new Base[0] : new Base[] {this.service}; // Coding
- case 615164076: /*serviceModifier*/ return this.serviceModifier == null ? new Base[0] : this.serviceModifier.toArray(new Base[this.serviceModifier.size()]); // Coding
case -615513385: /*modifier*/ return this.modifier == null ? new Base[0] : this.modifier.toArray(new Base[this.modifier.size()]); // Coding
case 1010065041: /*programCode*/ return this.programCode == null ? new Base[0] : this.programCode.toArray(new Base[this.programCode.size()]); // Coding
case 1379209295: /*serviced*/ return this.serviced == null ? new Base[0] : new Base[] {this.serviced}; // Type
- case -1163246198: /*serviceLocation*/ return this.serviceLocation == null ? new Base[0] : new Base[] {this.serviceLocation}; // Type
+ case 1901043637: /*location*/ return this.location == null ? new Base[0] : new Base[] {this.location}; // Type
case -1285004149: /*quantity*/ return this.quantity == null ? new Base[0] : new Base[] {this.quantity}; // SimpleQuantity
case -486196699: /*unitPrice*/ return this.unitPrice == null ? new Base[0] : new Base[] {this.unitPrice}; // Money
case -1282148017: /*factor*/ return this.factor == null ? new Base[0] : new Base[] {this.factor}; // DecimalType
@@ -3412,21 +3702,21 @@ public class Claim extends DomainResource {
case 1349547969: // sequence
this.sequence = castToPositiveInt(value); // PositiveIntType
break;
- case 3575610: // type
- this.type = castToCoding(value); // Coding
- break;
case -7323378: // careTeam
this.getCareTeam().add((CareTeamComponent) value); // CareTeamComponent
break;
case -1659207418: // diagnosisLinkId
this.getDiagnosisLinkId().add(castToPositiveInt(value)); // PositiveIntType
break;
+ case 1099842588: // revenue
+ this.revenue = castToCoding(value); // Coding
+ break;
+ case 50511102: // category
+ this.category = castToCoding(value); // Coding
+ break;
case 1984153269: // service
this.service = castToCoding(value); // Coding
break;
- case 615164076: // serviceModifier
- this.getServiceModifier().add(castToCoding(value)); // Coding
- break;
case -615513385: // modifier
this.getModifier().add(castToCoding(value)); // Coding
break;
@@ -3436,8 +3726,8 @@ public class Claim extends DomainResource {
case 1379209295: // serviced
this.serviced = (Type) value; // Type
break;
- case -1163246198: // serviceLocation
- this.serviceLocation = (Type) value; // Type
+ case 1901043637: // location
+ this.location = (Type) value; // Type
break;
case -1285004149: // quantity
this.quantity = castToSimpleQuantity(value); // SimpleQuantity
@@ -3478,24 +3768,24 @@ public class Claim extends DomainResource {
public void setProperty(String name, Base value) throws FHIRException {
if (name.equals("sequence"))
this.sequence = castToPositiveInt(value); // PositiveIntType
- else if (name.equals("type"))
- this.type = castToCoding(value); // Coding
else if (name.equals("careTeam"))
this.getCareTeam().add((CareTeamComponent) value);
else if (name.equals("diagnosisLinkId"))
this.getDiagnosisLinkId().add(castToPositiveInt(value));
+ else if (name.equals("revenue"))
+ this.revenue = castToCoding(value); // Coding
+ else if (name.equals("category"))
+ this.category = castToCoding(value); // Coding
else if (name.equals("service"))
this.service = castToCoding(value); // Coding
- else if (name.equals("serviceModifier"))
- this.getServiceModifier().add(castToCoding(value));
else if (name.equals("modifier"))
this.getModifier().add(castToCoding(value));
else if (name.equals("programCode"))
this.getProgramCode().add(castToCoding(value));
else if (name.equals("serviced[x]"))
this.serviced = (Type) value; // Type
- else if (name.equals("serviceLocation[x]"))
- this.serviceLocation = (Type) value; // Type
+ else if (name.equals("location[x]"))
+ this.location = (Type) value; // Type
else if (name.equals("quantity"))
this.quantity = castToSimpleQuantity(value); // SimpleQuantity
else if (name.equals("unitPrice"))
@@ -3524,15 +3814,15 @@ public class Claim extends DomainResource {
public Base makeProperty(int hash, String name) throws FHIRException {
switch (hash) {
case 1349547969: throw new FHIRException("Cannot make property sequence as it is not a complex type"); // PositiveIntType
- case 3575610: return getType(); // Coding
case -7323378: return addCareTeam(); // CareTeamComponent
case -1659207418: throw new FHIRException("Cannot make property diagnosisLinkId as it is not a complex type"); // PositiveIntType
+ case 1099842588: return getRevenue(); // Coding
+ case 50511102: return getCategory(); // Coding
case 1984153269: return getService(); // Coding
- case 615164076: return addServiceModifier(); // Coding
case -615513385: return addModifier(); // Coding
case 1010065041: return addProgramCode(); // Coding
case -1927922223: return getServiced(); // Type
- case 1823718070: return getServiceLocation(); // Type
+ case 552316075: return getLocation(); // Type
case -1285004149: return getQuantity(); // SimpleQuantity
case -486196699: return getUnitPrice(); // Money
case -1282148017: throw new FHIRException("Cannot make property factor as it is not a complex type"); // DecimalType
@@ -3553,23 +3843,24 @@ public class Claim extends DomainResource {
if (name.equals("sequence")) {
throw new FHIRException("Cannot call addChild on a primitive type Claim.sequence");
}
- else if (name.equals("type")) {
- this.type = new Coding();
- return this.type;
- }
else if (name.equals("careTeam")) {
return addCareTeam();
}
else if (name.equals("diagnosisLinkId")) {
throw new FHIRException("Cannot call addChild on a primitive type Claim.diagnosisLinkId");
}
+ else if (name.equals("revenue")) {
+ this.revenue = new Coding();
+ return this.revenue;
+ }
+ else if (name.equals("category")) {
+ this.category = new Coding();
+ return this.category;
+ }
else if (name.equals("service")) {
this.service = new Coding();
return this.service;
}
- else if (name.equals("serviceModifier")) {
- return addServiceModifier();
- }
else if (name.equals("modifier")) {
return addModifier();
}
@@ -3584,17 +3875,17 @@ public class Claim extends DomainResource {
this.serviced = new Period();
return this.serviced;
}
- else if (name.equals("serviceLocationCoding")) {
- this.serviceLocation = new Coding();
- return this.serviceLocation;
+ else if (name.equals("locationCoding")) {
+ this.location = new Coding();
+ return this.location;
}
- else if (name.equals("serviceLocationAddress")) {
- this.serviceLocation = new Address();
- return this.serviceLocation;
+ else if (name.equals("locationAddress")) {
+ this.location = new Address();
+ return this.location;
}
- else if (name.equals("serviceLocationReference")) {
- this.serviceLocation = new Reference();
- return this.serviceLocation;
+ else if (name.equals("locationReference")) {
+ this.location = new Reference();
+ return this.location;
}
else if (name.equals("quantity")) {
this.quantity = new SimpleQuantity();
@@ -3639,7 +3930,6 @@ public class Claim extends DomainResource {
ItemComponent dst = new ItemComponent();
copyValues(dst);
dst.sequence = sequence == null ? null : sequence.copy();
- dst.type = type == null ? null : type.copy();
if (careTeam != null) {
dst.careTeam = new ArrayList();
for (CareTeamComponent i : careTeam)
@@ -3650,12 +3940,9 @@ public class Claim extends DomainResource {
for (PositiveIntType i : diagnosisLinkId)
dst.diagnosisLinkId.add(i.copy());
};
+ dst.revenue = revenue == null ? null : revenue.copy();
+ dst.category = category == null ? null : category.copy();
dst.service = service == null ? null : service.copy();
- if (serviceModifier != null) {
- dst.serviceModifier = new ArrayList();
- for (Coding i : serviceModifier)
- dst.serviceModifier.add(i.copy());
- };
if (modifier != null) {
dst.modifier = new ArrayList();
for (Coding i : modifier)
@@ -3667,7 +3954,7 @@ public class Claim extends DomainResource {
dst.programCode.add(i.copy());
};
dst.serviced = serviced == null ? null : serviced.copy();
- dst.serviceLocation = serviceLocation == null ? null : serviceLocation.copy();
+ dst.location = location == null ? null : location.copy();
dst.quantity = quantity == null ? null : quantity.copy();
dst.unitPrice = unitPrice == null ? null : unitPrice.copy();
dst.factor = factor == null ? null : factor.copy();
@@ -3700,14 +3987,13 @@ public class Claim extends DomainResource {
if (!(other instanceof ItemComponent))
return false;
ItemComponent o = (ItemComponent) other;
- return compareDeep(sequence, o.sequence, true) && compareDeep(type, o.type, true) && compareDeep(careTeam, o.careTeam, true)
- && compareDeep(diagnosisLinkId, o.diagnosisLinkId, true) && compareDeep(service, o.service, true)
- && compareDeep(serviceModifier, o.serviceModifier, true) && compareDeep(modifier, o.modifier, true)
- && compareDeep(programCode, o.programCode, true) && compareDeep(serviced, o.serviced, true) && compareDeep(serviceLocation, o.serviceLocation, true)
- && compareDeep(quantity, o.quantity, true) && compareDeep(unitPrice, o.unitPrice, true) && compareDeep(factor, o.factor, true)
- && compareDeep(points, o.points, true) && compareDeep(net, o.net, true) && compareDeep(udi, o.udi, true)
- && compareDeep(bodySite, o.bodySite, true) && compareDeep(subSite, o.subSite, true) && compareDeep(detail, o.detail, true)
- && compareDeep(prosthesis, o.prosthesis, true);
+ return compareDeep(sequence, o.sequence, true) && compareDeep(careTeam, o.careTeam, true) && compareDeep(diagnosisLinkId, o.diagnosisLinkId, true)
+ && compareDeep(revenue, o.revenue, true) && compareDeep(category, o.category, true) && compareDeep(service, o.service, true)
+ && compareDeep(modifier, o.modifier, true) && compareDeep(programCode, o.programCode, true) && compareDeep(serviced, o.serviced, true)
+ && compareDeep(location, o.location, true) && compareDeep(quantity, o.quantity, true) && compareDeep(unitPrice, o.unitPrice, true)
+ && compareDeep(factor, o.factor, true) && compareDeep(points, o.points, true) && compareDeep(net, o.net, true)
+ && compareDeep(udi, o.udi, true) && compareDeep(bodySite, o.bodySite, true) && compareDeep(subSite, o.subSite, true)
+ && compareDeep(detail, o.detail, true) && compareDeep(prosthesis, o.prosthesis, true);
}
@Override
@@ -3722,10 +4008,10 @@ public class Claim extends DomainResource {
}
public boolean isEmpty() {
- return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(sequence, type, careTeam
- , diagnosisLinkId, service, serviceModifier, modifier, programCode, serviced, serviceLocation
- , quantity, unitPrice, factor, points, net, udi, bodySite, subSite, detail
- , prosthesis);
+ return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(sequence, careTeam, diagnosisLinkId
+ , revenue, category, service, modifier, programCode, serviced, location, quantity
+ , unitPrice, factor, points, net, udi, bodySite, subSite, detail, prosthesis
+ );
}
public String fhirType() {
@@ -3738,31 +4024,33 @@ public class Claim extends DomainResource {
@Block()
public static class CareTeamComponent extends BackboneElement implements IBaseBackboneElement {
/**
- * The members of the team who provided the overall service.
+ * Member of the team who provided the overall service.
*/
- @Child(name = "provider", type = {Identifier.class, Practitioner.class}, order=1, min=1, max=1, modifier=false, summary=true)
- @Description(shortDefinition="", formalDefinition="The members of the team who provided the overall service." )
+ @Child(name = "provider", type = {Identifier.class, Practitioner.class, Organization.class}, order=1, min=1, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Provider individual or organization", formalDefinition="Member of the team who provided the overall service." )
protected Type provider;
/**
- * The practitioner who is billing and responsible for the claimed services rendered to the patient.
+ * The party who is billing and responsible for the claimed good or service rendered to the patient.
*/
- @Child(name = "responsible", type = {BooleanType.class}, order=2, min=0, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Billing practitioner", formalDefinition="The practitioner who is billing and responsible for the claimed services rendered to the patient." )
+ @Child(name = "responsible", type = {BooleanType.class}, order=2, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Billing provider", formalDefinition="The party who is billing and responsible for the claimed good or service rendered to the patient." )
protected BooleanType responsible;
/**
* The lead, assisting or supervising practitioner and their discipline if a multidisiplinary team.
*/
- @Child(name = "role", type = {Coding.class}, order=3, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "role", type = {Coding.class}, order=3, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Role on the team", formalDefinition="The lead, assisting or supervising practitioner and their discipline if a multidisiplinary team." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/claim-careteamrole")
protected Coding role;
/**
* The qualification which is applicable for this service.
*/
- @Child(name = "qualification", type = {Coding.class}, order=4, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "qualification", type = {Coding.class}, order=4, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Type, classification or Specialization", formalDefinition="The qualification which is applicable for this service." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/provider-qualification")
protected Coding qualification;
private static final long serialVersionUID = 31082634L;
@@ -3783,14 +4071,14 @@ public class Claim extends DomainResource {
}
/**
- * @return {@link #provider} (The members of the team who provided the overall service.)
+ * @return {@link #provider} (Member of the team who provided the overall service.)
*/
public Type getProvider() {
return this.provider;
}
/**
- * @return {@link #provider} (The members of the team who provided the overall service.)
+ * @return {@link #provider} (Member of the team who provided the overall service.)
*/
public Identifier getProviderIdentifier() throws FHIRException {
if (!(this.provider instanceof Identifier))
@@ -3803,7 +4091,7 @@ public class Claim extends DomainResource {
}
/**
- * @return {@link #provider} (The members of the team who provided the overall service.)
+ * @return {@link #provider} (Member of the team who provided the overall service.)
*/
public Reference getProviderReference() throws FHIRException {
if (!(this.provider instanceof Reference))
@@ -3820,7 +4108,7 @@ public class Claim extends DomainResource {
}
/**
- * @param value {@link #provider} (The members of the team who provided the overall service.)
+ * @param value {@link #provider} (Member of the team who provided the overall service.)
*/
public CareTeamComponent setProvider(Type value) {
this.provider = value;
@@ -3828,7 +4116,7 @@ public class Claim extends DomainResource {
}
/**
- * @return {@link #responsible} (The practitioner who is billing and responsible for the claimed services rendered to the patient.). This is the underlying object with id, value and extensions. The accessor "getResponsible" gives direct access to the value
+ * @return {@link #responsible} (The party who is billing and responsible for the claimed good or service rendered to the patient.). This is the underlying object with id, value and extensions. The accessor "getResponsible" gives direct access to the value
*/
public BooleanType getResponsibleElement() {
if (this.responsible == null)
@@ -3848,7 +4136,7 @@ public class Claim extends DomainResource {
}
/**
- * @param value {@link #responsible} (The practitioner who is billing and responsible for the claimed services rendered to the patient.). This is the underlying object with id, value and extensions. The accessor "getResponsible" gives direct access to the value
+ * @param value {@link #responsible} (The party who is billing and responsible for the claimed good or service rendered to the patient.). This is the underlying object with id, value and extensions. The accessor "getResponsible" gives direct access to the value
*/
public CareTeamComponent setResponsibleElement(BooleanType value) {
this.responsible = value;
@@ -3856,14 +4144,14 @@ public class Claim extends DomainResource {
}
/**
- * @return The practitioner who is billing and responsible for the claimed services rendered to the patient.
+ * @return The party who is billing and responsible for the claimed good or service rendered to the patient.
*/
public boolean getResponsible() {
return this.responsible == null || this.responsible.isEmpty() ? false : this.responsible.getValue();
}
/**
- * @param value The practitioner who is billing and responsible for the claimed services rendered to the patient.
+ * @param value The party who is billing and responsible for the claimed good or service rendered to the patient.
*/
public CareTeamComponent setResponsible(boolean value) {
if (this.responsible == null)
@@ -3922,8 +4210,8 @@ public class Claim extends DomainResource {
protected void listChildren(List childrenList) {
super.listChildren(childrenList);
- childrenList.add(new Property("provider[x]", "Identifier|Reference(Practitioner)", "The members of the team who provided the overall service.", 0, java.lang.Integer.MAX_VALUE, provider));
- childrenList.add(new Property("responsible", "boolean", "The practitioner who is billing and responsible for the claimed services rendered to the patient.", 0, java.lang.Integer.MAX_VALUE, responsible));
+ childrenList.add(new Property("provider[x]", "Identifier|Reference(Practitioner|Organization)", "Member of the team who provided the overall service.", 0, java.lang.Integer.MAX_VALUE, provider));
+ childrenList.add(new Property("responsible", "boolean", "The party who is billing and responsible for the claimed good or service rendered to the patient.", 0, java.lang.Integer.MAX_VALUE, responsible));
childrenList.add(new Property("role", "Coding", "The lead, assisting or supervising practitioner and their discipline if a multidisiplinary team.", 0, java.lang.Integer.MAX_VALUE, role));
childrenList.add(new Property("qualification", "Coding", "The qualification which is applicable for this service.", 0, java.lang.Integer.MAX_VALUE, qualification));
}
@@ -4059,70 +4347,89 @@ public class Claim extends DomainResource {
/**
* A service line number.
*/
- @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="Service instance", formalDefinition="A service line number." )
protected PositiveIntType sequence;
/**
- * The type of product or service.
+ * The type of reveneu or cost center providing the product and/or service.
*/
- @Child(name = "type", type = {Coding.class}, order=2, min=1, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Group or type of product or service", formalDefinition="The type of product or service." )
- protected Coding type;
+ @Child(name = "revenue", type = {Coding.class}, order=2, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Revenue or cost center code", formalDefinition="The type of reveneu or cost center providing the product and/or service." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/ex-revenue-center")
+ protected Coding revenue;
/**
- * If a grouping item then 'GROUP' otherwise it is a node therefore a code to indicate the Professional Service or Product supplied.
+ * Health Care Service Type Codes to identify the classification of service or benefits.
*/
- @Child(name = "service", type = {Coding.class}, order=3, min=1, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Additional item codes", formalDefinition="If a grouping item then 'GROUP' otherwise it is a node therefore a code to indicate the Professional Service or Product supplied." )
+ @Child(name = "category", type = {Coding.class}, order=3, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Type of service or product", formalDefinition="Health Care Service Type Codes to identify the classification of service or benefits." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/benefit-subcategory")
+ protected Coding category;
+
+ /**
+ * If this is an actual service or product line, ie. not a Group, then use code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI). If a grouping item then use a group code to indicate the type of thing being grouped eg. 'glasses' or 'compound'.
+ */
+ @Child(name = "service", type = {Coding.class}, order=4, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Billing Code", formalDefinition="If this is an actual service or product line, ie. not a Group, then use code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI). If a grouping item then use a group code to indicate the type of thing being grouped eg. 'glasses' or 'compound'." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/service-uscls")
protected Coding service;
+ /**
+ * Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours.
+ */
+ @Child(name = "modifier", type = {Coding.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="Service/Product billing modifiers", formalDefinition="Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/claim-modifiers")
+ protected List modifier;
+
/**
* For programs which require reson codes for the inclusion, covering, of this billed item under the program or sub-program.
*/
- @Child(name = "programCode", type = {Coding.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "programCode", type = {Coding.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Program specific reason for item inclusion", formalDefinition="For programs which require reson codes for the inclusion, covering, of this billed item under the program or sub-program." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/ex-program-code")
protected List programCode;
/**
* The number of repetitions of a service or product.
*/
- @Child(name = "quantity", type = {SimpleQuantity.class}, order=5, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "quantity", type = {SimpleQuantity.class}, order=7, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Count of Products or Services", formalDefinition="The number of repetitions of a service or product." )
protected SimpleQuantity quantity;
/**
* If the item is a node then this is the fee for the product or service, otherwise this is the total of the fees for the children of the group.
*/
- @Child(name = "unitPrice", type = {Money.class}, order=6, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "unitPrice", type = {Money.class}, order=8, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Fee, charge or cost per point", formalDefinition="If the item is a node then this is the fee for the product or service, otherwise this is the total of the fees for the children of the group." )
protected Money unitPrice;
/**
* A real number that represents a multiplier used in determining the overall value of services delivered and/or goods received. The concept of a Factor allows for a discount or surcharge multiplier to be applied to a monetary amount.
*/
- @Child(name = "factor", type = {DecimalType.class}, order=7, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "factor", type = {DecimalType.class}, order=9, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Price scaling factor", formalDefinition="A real number that represents a multiplier used in determining the overall value of services delivered and/or goods received. The concept of a Factor allows for a discount or surcharge multiplier to be applied to a monetary amount." )
protected DecimalType factor;
/**
* An amount that expresses the weighting (based on difficulty, cost and/or resource intensiveness) associated with the good or service delivered. The concept of Points allows for assignment of point values for services and/or goods, such that a monetary amount can be assigned to each point.
*/
- @Child(name = "points", type = {DecimalType.class}, order=8, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "points", type = {DecimalType.class}, order=10, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Difficulty scaling factor", formalDefinition="An amount that expresses the weighting (based on difficulty, cost and/or resource intensiveness) associated with the good or service delivered. The concept of Points allows for assignment of point values for services and/or goods, such that a monetary amount can be assigned to each point." )
protected DecimalType points;
/**
* The quantity times the unit price for an addittional service or product or charge. For example, the formula: unit Quantity * unit Price (Cost per Point) * factor Number * points = net Amount. Quantity, factor and points are assumed to be 1 if not supplied.
*/
- @Child(name = "net", type = {Money.class}, order=9, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "net", type = {Money.class}, order=11, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Total additional item cost", formalDefinition="The quantity times the unit price for an addittional service or product or charge. For example, the formula: unit Quantity * unit Price (Cost per Point) * factor Number * points = net Amount. Quantity, factor and points are assumed to be 1 if not supplied." )
protected Money net;
/**
* List of Unique Device Identifiers associated with this line item.
*/
- @Child(name = "udi", type = {Device.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "udi", type = {Device.class}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Unique Device Identifier", formalDefinition="List of Unique Device Identifiers associated with this line item." )
protected List udi;
/**
@@ -4134,11 +4441,11 @@ public class Claim extends DomainResource {
/**
* Third tier of goods and services.
*/
- @Child(name = "subDetail", type = {}, order=11, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "subDetail", type = {}, order=13, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Additional items", formalDefinition="Third tier of goods and services." )
protected List subDetail;
- private static final long serialVersionUID = -1099698352L;
+ private static final long serialVersionUID = -753919335L;
/**
* Constructor
@@ -4150,11 +4457,9 @@ public class Claim extends DomainResource {
/**
* Constructor
*/
- public DetailComponent(PositiveIntType sequence, Coding type, Coding service) {
+ public DetailComponent(PositiveIntType sequence) {
super();
this.sequence = sequence;
- this.type = type;
- this.service = service;
}
/**
@@ -4203,31 +4508,55 @@ public class Claim extends DomainResource {
}
/**
- * @return {@link #type} (The type of product or service.)
+ * @return {@link #revenue} (The type of reveneu or cost center providing the product and/or service.)
*/
- public Coding getType() {
- if (this.type == null)
+ public Coding getRevenue() {
+ if (this.revenue == null)
if (Configuration.errorOnAutoCreate())
- throw new Error("Attempt to auto-create DetailComponent.type");
+ throw new Error("Attempt to auto-create DetailComponent.revenue");
else if (Configuration.doAutoCreate())
- this.type = new Coding(); // cc
- return this.type;
+ this.revenue = new Coding(); // cc
+ return this.revenue;
}
- public boolean hasType() {
- return this.type != null && !this.type.isEmpty();
+ public boolean hasRevenue() {
+ return this.revenue != null && !this.revenue.isEmpty();
}
/**
- * @param value {@link #type} (The type of product or service.)
+ * @param value {@link #revenue} (The type of reveneu or cost center providing the product and/or service.)
*/
- public DetailComponent setType(Coding value) {
- this.type = value;
+ public DetailComponent setRevenue(Coding value) {
+ this.revenue = value;
return this;
}
/**
- * @return {@link #service} (If a grouping item then 'GROUP' otherwise it is a node therefore a code to indicate the Professional Service or Product supplied.)
+ * @return {@link #category} (Health Care Service Type Codes to identify the classification of service or benefits.)
+ */
+ public Coding getCategory() {
+ if (this.category == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create DetailComponent.category");
+ else if (Configuration.doAutoCreate())
+ this.category = new Coding(); // cc
+ return this.category;
+ }
+
+ public boolean hasCategory() {
+ return this.category != null && !this.category.isEmpty();
+ }
+
+ /**
+ * @param value {@link #category} (Health Care Service Type Codes to identify the classification of service or benefits.)
+ */
+ public DetailComponent setCategory(Coding value) {
+ this.category = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #service} (If this is an actual service or product line, ie. not a Group, then use code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI). If a grouping item then use a group code to indicate the type of thing being grouped eg. 'glasses' or 'compound'.)
*/
public Coding getService() {
if (this.service == null)
@@ -4243,13 +4572,66 @@ public class Claim extends DomainResource {
}
/**
- * @param value {@link #service} (If a grouping item then 'GROUP' otherwise it is a node therefore a code to indicate the Professional Service or Product supplied.)
+ * @param value {@link #service} (If this is an actual service or product line, ie. not a Group, then use code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI). If a grouping item then use a group code to indicate the type of thing being grouped eg. 'glasses' or 'compound'.)
*/
public DetailComponent setService(Coding value) {
this.service = value;
return this;
}
+ /**
+ * @return {@link #modifier} (Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours.)
+ */
+ public List getModifier() {
+ if (this.modifier == null)
+ this.modifier = new ArrayList();
+ return this.modifier;
+ }
+
+ /**
+ * @return Returns a reference to this
for easy method chaining
+ */
+ public DetailComponent setModifier(List theModifier) {
+ this.modifier = theModifier;
+ return this;
+ }
+
+ public boolean hasModifier() {
+ if (this.modifier == null)
+ return false;
+ for (Coding item : this.modifier)
+ if (!item.isEmpty())
+ return true;
+ return false;
+ }
+
+ public Coding addModifier() { //3
+ Coding t = new Coding();
+ if (this.modifier == null)
+ this.modifier = new ArrayList();
+ this.modifier.add(t);
+ return t;
+ }
+
+ public DetailComponent addModifier(Coding t) { //3
+ if (t == null)
+ return this;
+ if (this.modifier == null)
+ this.modifier = new ArrayList();
+ this.modifier.add(t);
+ return this;
+ }
+
+ /**
+ * @return The first repetition of repeating field {@link #modifier}, creating it if it does not already exist
+ */
+ public Coding getModifierFirstRep() {
+ if (getModifier().isEmpty()) {
+ addModifier();
+ }
+ return getModifier().get(0);
+ }
+
/**
* @return {@link #programCode} (For programs which require reson codes for the inclusion, covering, of this billed item under the program or sub-program.)
*/
@@ -4640,8 +5022,10 @@ public class Claim extends DomainResource {
protected void listChildren(List childrenList) {
super.listChildren(childrenList);
childrenList.add(new Property("sequence", "positiveInt", "A service line number.", 0, java.lang.Integer.MAX_VALUE, sequence));
- childrenList.add(new Property("type", "Coding", "The type of product or service.", 0, java.lang.Integer.MAX_VALUE, type));
- childrenList.add(new Property("service", "Coding", "If a grouping item then 'GROUP' otherwise it is a node therefore a code to indicate the Professional Service or Product supplied.", 0, java.lang.Integer.MAX_VALUE, service));
+ childrenList.add(new Property("revenue", "Coding", "The type of reveneu or cost center providing the product and/or service.", 0, java.lang.Integer.MAX_VALUE, revenue));
+ childrenList.add(new Property("category", "Coding", "Health Care Service Type Codes to identify the classification of service or benefits.", 0, java.lang.Integer.MAX_VALUE, category));
+ childrenList.add(new Property("service", "Coding", "If this is an actual service or product line, ie. not a Group, then use code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI). If a grouping item then use a group code to indicate the type of thing being grouped eg. 'glasses' or 'compound'.", 0, java.lang.Integer.MAX_VALUE, service));
+ childrenList.add(new Property("modifier", "Coding", "Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours.", 0, java.lang.Integer.MAX_VALUE, modifier));
childrenList.add(new Property("programCode", "Coding", "For programs which require reson codes for the inclusion, covering, of this billed item under the program or sub-program.", 0, java.lang.Integer.MAX_VALUE, programCode));
childrenList.add(new Property("quantity", "SimpleQuantity", "The number of repetitions of a service or product.", 0, java.lang.Integer.MAX_VALUE, quantity));
childrenList.add(new Property("unitPrice", "Money", "If the item is a node then this is the fee for the product or service, otherwise this is the total of the fees for the children of the group.", 0, java.lang.Integer.MAX_VALUE, unitPrice));
@@ -4656,8 +5040,10 @@ public class Claim extends DomainResource {
public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
switch (hash) {
case 1349547969: /*sequence*/ return this.sequence == null ? new Base[0] : new Base[] {this.sequence}; // PositiveIntType
- case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Coding
+ case 1099842588: /*revenue*/ return this.revenue == null ? new Base[0] : new Base[] {this.revenue}; // Coding
+ case 50511102: /*category*/ return this.category == null ? new Base[0] : new Base[] {this.category}; // Coding
case 1984153269: /*service*/ return this.service == null ? new Base[0] : new Base[] {this.service}; // Coding
+ case -615513385: /*modifier*/ return this.modifier == null ? new Base[0] : this.modifier.toArray(new Base[this.modifier.size()]); // Coding
case 1010065041: /*programCode*/ return this.programCode == null ? new Base[0] : this.programCode.toArray(new Base[this.programCode.size()]); // Coding
case -1285004149: /*quantity*/ return this.quantity == null ? new Base[0] : new Base[] {this.quantity}; // SimpleQuantity
case -486196699: /*unitPrice*/ return this.unitPrice == null ? new Base[0] : new Base[] {this.unitPrice}; // Money
@@ -4677,12 +5063,18 @@ public class Claim extends DomainResource {
case 1349547969: // sequence
this.sequence = castToPositiveInt(value); // PositiveIntType
break;
- case 3575610: // type
- this.type = castToCoding(value); // Coding
+ case 1099842588: // revenue
+ this.revenue = castToCoding(value); // Coding
+ break;
+ case 50511102: // category
+ this.category = castToCoding(value); // Coding
break;
case 1984153269: // service
this.service = castToCoding(value); // Coding
break;
+ case -615513385: // modifier
+ this.getModifier().add(castToCoding(value)); // Coding
+ break;
case 1010065041: // programCode
this.getProgramCode().add(castToCoding(value)); // Coding
break;
@@ -4716,10 +5108,14 @@ public class Claim extends DomainResource {
public void setProperty(String name, Base value) throws FHIRException {
if (name.equals("sequence"))
this.sequence = castToPositiveInt(value); // PositiveIntType
- else if (name.equals("type"))
- this.type = castToCoding(value); // Coding
+ else if (name.equals("revenue"))
+ this.revenue = castToCoding(value); // Coding
+ else if (name.equals("category"))
+ this.category = castToCoding(value); // Coding
else if (name.equals("service"))
this.service = castToCoding(value); // Coding
+ else if (name.equals("modifier"))
+ this.getModifier().add(castToCoding(value));
else if (name.equals("programCode"))
this.getProgramCode().add(castToCoding(value));
else if (name.equals("quantity"))
@@ -4744,8 +5140,10 @@ public class Claim extends DomainResource {
public Base makeProperty(int hash, String name) throws FHIRException {
switch (hash) {
case 1349547969: throw new FHIRException("Cannot make property sequence as it is not a complex type"); // PositiveIntType
- case 3575610: return getType(); // Coding
+ case 1099842588: return getRevenue(); // Coding
+ case 50511102: return getCategory(); // Coding
case 1984153269: return getService(); // Coding
+ case -615513385: return addModifier(); // Coding
case 1010065041: return addProgramCode(); // Coding
case -1285004149: return getQuantity(); // SimpleQuantity
case -486196699: return getUnitPrice(); // Money
@@ -4764,14 +5162,21 @@ public class Claim extends DomainResource {
if (name.equals("sequence")) {
throw new FHIRException("Cannot call addChild on a primitive type Claim.sequence");
}
- else if (name.equals("type")) {
- this.type = new Coding();
- return this.type;
+ else if (name.equals("revenue")) {
+ this.revenue = new Coding();
+ return this.revenue;
+ }
+ else if (name.equals("category")) {
+ this.category = new Coding();
+ return this.category;
}
else if (name.equals("service")) {
this.service = new Coding();
return this.service;
}
+ else if (name.equals("modifier")) {
+ return addModifier();
+ }
else if (name.equals("programCode")) {
return addProgramCode();
}
@@ -4807,8 +5212,14 @@ public class Claim extends DomainResource {
DetailComponent dst = new DetailComponent();
copyValues(dst);
dst.sequence = sequence == null ? null : sequence.copy();
- dst.type = type == null ? null : type.copy();
+ dst.revenue = revenue == null ? null : revenue.copy();
+ dst.category = category == null ? null : category.copy();
dst.service = service == null ? null : service.copy();
+ if (modifier != null) {
+ dst.modifier = new ArrayList();
+ for (Coding i : modifier)
+ dst.modifier.add(i.copy());
+ };
if (programCode != null) {
dst.programCode = new ArrayList();
for (Coding i : programCode)
@@ -4839,10 +5250,11 @@ public class Claim extends DomainResource {
if (!(other instanceof DetailComponent))
return false;
DetailComponent o = (DetailComponent) other;
- return compareDeep(sequence, o.sequence, true) && compareDeep(type, o.type, true) && compareDeep(service, o.service, true)
- && compareDeep(programCode, o.programCode, true) && compareDeep(quantity, o.quantity, true) && compareDeep(unitPrice, o.unitPrice, true)
- && compareDeep(factor, o.factor, true) && compareDeep(points, o.points, true) && compareDeep(net, o.net, true)
- && compareDeep(udi, o.udi, true) && compareDeep(subDetail, o.subDetail, true);
+ return compareDeep(sequence, o.sequence, true) && compareDeep(revenue, o.revenue, true) && compareDeep(category, o.category, true)
+ && compareDeep(service, o.service, true) && compareDeep(modifier, o.modifier, true) && compareDeep(programCode, o.programCode, true)
+ && compareDeep(quantity, o.quantity, true) && compareDeep(unitPrice, o.unitPrice, true) && compareDeep(factor, o.factor, true)
+ && compareDeep(points, o.points, true) && compareDeep(net, o.net, true) && compareDeep(udi, o.udi, true)
+ && compareDeep(subDetail, o.subDetail, true);
}
@Override
@@ -4857,8 +5269,9 @@ public class Claim extends DomainResource {
}
public boolean isEmpty() {
- return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(sequence, type, service
- , programCode, quantity, unitPrice, factor, points, net, udi, subDetail);
+ return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(sequence, revenue, category
+ , service, modifier, programCode, quantity, unitPrice, factor, points, net, udi
+ , subDetail);
}
public String fhirType() {
@@ -4873,70 +5286,89 @@ public class Claim extends DomainResource {
/**
* A service line number.
*/
- @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=true)
+ @Child(name = "sequence", type = {PositiveIntType.class}, order=1, min=1, max=1, modifier=false, summary=false)
@Description(shortDefinition="Service instance", formalDefinition="A service line number." )
protected PositiveIntType sequence;
/**
- * The type of product or service.
+ * The type of reveneu or cost center providing the product and/or service.
*/
- @Child(name = "type", type = {Coding.class}, order=2, min=1, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Type of product or service", formalDefinition="The type of product or service." )
- protected Coding type;
+ @Child(name = "revenue", type = {Coding.class}, order=2, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Revenue or cost center code", formalDefinition="The type of reveneu or cost center providing the product and/or service." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/ex-revenue-center")
+ protected Coding revenue;
/**
- * The fee for an addittional service or product or charge.
+ * Health Care Service Type Codes to identify the classification of service or benefits.
*/
- @Child(name = "service", type = {Coding.class}, order=3, min=1, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Additional item codes", formalDefinition="The fee for an addittional service or product or charge." )
+ @Child(name = "category", type = {Coding.class}, order=3, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Type of service or product", formalDefinition="Health Care Service Type Codes to identify the classification of service or benefits." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/benefit-subcategory")
+ protected Coding category;
+
+ /**
+ * A code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI).
+ */
+ @Child(name = "service", type = {Coding.class}, order=4, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Billing Code", formalDefinition="A code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI)." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/service-uscls")
protected Coding service;
+ /**
+ * Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours.
+ */
+ @Child(name = "modifier", type = {Coding.class}, order=5, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="Service/Product billing modifiers", formalDefinition="Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/claim-modifiers")
+ protected List modifier;
+
/**
* For programs which require reson codes for the inclusion, covering, of this billed item under the program or sub-program.
*/
- @Child(name = "programCode", type = {Coding.class}, order=4, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "programCode", type = {Coding.class}, order=6, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Program specific reason for item inclusion", formalDefinition="For programs which require reson codes for the inclusion, covering, of this billed item under the program or sub-program." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/ex-program-code")
protected List programCode;
/**
* The number of repetitions of a service or product.
*/
- @Child(name = "quantity", type = {SimpleQuantity.class}, order=5, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "quantity", type = {SimpleQuantity.class}, order=7, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Count of Products or Services", formalDefinition="The number of repetitions of a service or product." )
protected SimpleQuantity quantity;
/**
* The fee for an addittional service or product or charge.
*/
- @Child(name = "unitPrice", type = {Money.class}, order=6, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "unitPrice", type = {Money.class}, order=8, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Fee, charge or cost per point", formalDefinition="The fee for an addittional service or product or charge." )
protected Money unitPrice;
/**
* A real number that represents a multiplier used in determining the overall value of services delivered and/or goods received. The concept of a Factor allows for a discount or surcharge multiplier to be applied to a monetary amount.
*/
- @Child(name = "factor", type = {DecimalType.class}, order=7, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "factor", type = {DecimalType.class}, order=9, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Price scaling factor", formalDefinition="A real number that represents a multiplier used in determining the overall value of services delivered and/or goods received. The concept of a Factor allows for a discount or surcharge multiplier to be applied to a monetary amount." )
protected DecimalType factor;
/**
* An amount that expresses the weighting (based on difficulty, cost and/or resource intensiveness) associated with the good or service delivered. The concept of Points allows for assignment of point values for services and/or goods, such that a monetary amount can be assigned to each point.
*/
- @Child(name = "points", type = {DecimalType.class}, order=8, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "points", type = {DecimalType.class}, order=10, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Difficulty scaling factor", formalDefinition="An amount that expresses the weighting (based on difficulty, cost and/or resource intensiveness) associated with the good or service delivered. The concept of Points allows for assignment of point values for services and/or goods, such that a monetary amount can be assigned to each point." )
protected DecimalType points;
/**
* The quantity times the unit price for an addittional service or product or charge. For example, the formula: unit Quantity * unit Price (Cost per Point) * factor Number * points = net Amount. Quantity, factor and points are assumed to be 1 if not supplied.
*/
- @Child(name = "net", type = {Money.class}, order=9, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "net", type = {Money.class}, order=11, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Net additional item cost", formalDefinition="The quantity times the unit price for an addittional service or product or charge. For example, the formula: unit Quantity * unit Price (Cost per Point) * factor Number * points = net Amount. Quantity, factor and points are assumed to be 1 if not supplied." )
protected Money net;
/**
* List of Unique Device Identifiers associated with this line item.
*/
- @Child(name = "udi", type = {Device.class}, order=10, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "udi", type = {Device.class}, order=12, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Unique Device Identifier", formalDefinition="List of Unique Device Identifiers associated with this line item." )
protected List udi;
/**
@@ -4945,7 +5377,7 @@ public class Claim extends DomainResource {
protected List udiTarget;
- private static final long serialVersionUID = 846630321L;
+ private static final long serialVersionUID = 1424899208L;
/**
* Constructor
@@ -4957,11 +5389,9 @@ public class Claim extends DomainResource {
/**
* Constructor
*/
- public SubDetailComponent(PositiveIntType sequence, Coding type, Coding service) {
+ public SubDetailComponent(PositiveIntType sequence) {
super();
this.sequence = sequence;
- this.type = type;
- this.service = service;
}
/**
@@ -5010,31 +5440,55 @@ public class Claim extends DomainResource {
}
/**
- * @return {@link #type} (The type of product or service.)
+ * @return {@link #revenue} (The type of reveneu or cost center providing the product and/or service.)
*/
- public Coding getType() {
- if (this.type == null)
+ public Coding getRevenue() {
+ if (this.revenue == null)
if (Configuration.errorOnAutoCreate())
- throw new Error("Attempt to auto-create SubDetailComponent.type");
+ throw new Error("Attempt to auto-create SubDetailComponent.revenue");
else if (Configuration.doAutoCreate())
- this.type = new Coding(); // cc
- return this.type;
+ this.revenue = new Coding(); // cc
+ return this.revenue;
}
- public boolean hasType() {
- return this.type != null && !this.type.isEmpty();
+ public boolean hasRevenue() {
+ return this.revenue != null && !this.revenue.isEmpty();
}
/**
- * @param value {@link #type} (The type of product or service.)
+ * @param value {@link #revenue} (The type of reveneu or cost center providing the product and/or service.)
*/
- public SubDetailComponent setType(Coding value) {
- this.type = value;
+ public SubDetailComponent setRevenue(Coding value) {
+ this.revenue = value;
return this;
}
/**
- * @return {@link #service} (The fee for an addittional service or product or charge.)
+ * @return {@link #category} (Health Care Service Type Codes to identify the classification of service or benefits.)
+ */
+ public Coding getCategory() {
+ if (this.category == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create SubDetailComponent.category");
+ else if (Configuration.doAutoCreate())
+ this.category = new Coding(); // cc
+ return this.category;
+ }
+
+ public boolean hasCategory() {
+ return this.category != null && !this.category.isEmpty();
+ }
+
+ /**
+ * @param value {@link #category} (Health Care Service Type Codes to identify the classification of service or benefits.)
+ */
+ public SubDetailComponent setCategory(Coding value) {
+ this.category = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #service} (A code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI).)
*/
public Coding getService() {
if (this.service == null)
@@ -5050,13 +5504,66 @@ public class Claim extends DomainResource {
}
/**
- * @param value {@link #service} (The fee for an addittional service or product or charge.)
+ * @param value {@link #service} (A code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI).)
*/
public SubDetailComponent setService(Coding value) {
this.service = value;
return this;
}
+ /**
+ * @return {@link #modifier} (Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours.)
+ */
+ public List getModifier() {
+ if (this.modifier == null)
+ this.modifier = new ArrayList();
+ return this.modifier;
+ }
+
+ /**
+ * @return Returns a reference to this
for easy method chaining
+ */
+ public SubDetailComponent setModifier(List theModifier) {
+ this.modifier = theModifier;
+ return this;
+ }
+
+ public boolean hasModifier() {
+ if (this.modifier == null)
+ return false;
+ for (Coding item : this.modifier)
+ if (!item.isEmpty())
+ return true;
+ return false;
+ }
+
+ public Coding addModifier() { //3
+ Coding t = new Coding();
+ if (this.modifier == null)
+ this.modifier = new ArrayList();
+ this.modifier.add(t);
+ return t;
+ }
+
+ public SubDetailComponent addModifier(Coding t) { //3
+ if (t == null)
+ return this;
+ if (this.modifier == null)
+ this.modifier = new ArrayList();
+ this.modifier.add(t);
+ return this;
+ }
+
+ /**
+ * @return The first repetition of repeating field {@link #modifier}, creating it if it does not already exist
+ */
+ public Coding getModifierFirstRep() {
+ if (getModifier().isEmpty()) {
+ addModifier();
+ }
+ return getModifier().get(0);
+ }
+
/**
* @return {@link #programCode} (For programs which require reson codes for the inclusion, covering, of this billed item under the program or sub-program.)
*/
@@ -5394,8 +5901,10 @@ public class Claim extends DomainResource {
protected void listChildren(List childrenList) {
super.listChildren(childrenList);
childrenList.add(new Property("sequence", "positiveInt", "A service line number.", 0, java.lang.Integer.MAX_VALUE, sequence));
- childrenList.add(new Property("type", "Coding", "The type of product or service.", 0, java.lang.Integer.MAX_VALUE, type));
- childrenList.add(new Property("service", "Coding", "The fee for an addittional service or product or charge.", 0, java.lang.Integer.MAX_VALUE, service));
+ childrenList.add(new Property("revenue", "Coding", "The type of reveneu or cost center providing the product and/or service.", 0, java.lang.Integer.MAX_VALUE, revenue));
+ childrenList.add(new Property("category", "Coding", "Health Care Service Type Codes to identify the classification of service or benefits.", 0, java.lang.Integer.MAX_VALUE, category));
+ childrenList.add(new Property("service", "Coding", "A code to indicate the Professional Service or Product supplied (eg. CTP, HCPCS,USCLS,ICD10, NCPDP,DIN,ACHI,CCI).", 0, java.lang.Integer.MAX_VALUE, service));
+ childrenList.add(new Property("modifier", "Coding", "Item typification or modifiers codes, eg for Oral whether the treatment is cosmetic or associated with TMJ, or for medical whether the treatment was outside the clinic or out of office hours.", 0, java.lang.Integer.MAX_VALUE, modifier));
childrenList.add(new Property("programCode", "Coding", "For programs which require reson codes for the inclusion, covering, of this billed item under the program or sub-program.", 0, java.lang.Integer.MAX_VALUE, programCode));
childrenList.add(new Property("quantity", "SimpleQuantity", "The number of repetitions of a service or product.", 0, java.lang.Integer.MAX_VALUE, quantity));
childrenList.add(new Property("unitPrice", "Money", "The fee for an addittional service or product or charge.", 0, java.lang.Integer.MAX_VALUE, unitPrice));
@@ -5409,8 +5918,10 @@ public class Claim extends DomainResource {
public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
switch (hash) {
case 1349547969: /*sequence*/ return this.sequence == null ? new Base[0] : new Base[] {this.sequence}; // PositiveIntType
- case 3575610: /*type*/ return this.type == null ? new Base[0] : new Base[] {this.type}; // Coding
+ case 1099842588: /*revenue*/ return this.revenue == null ? new Base[0] : new Base[] {this.revenue}; // Coding
+ case 50511102: /*category*/ return this.category == null ? new Base[0] : new Base[] {this.category}; // Coding
case 1984153269: /*service*/ return this.service == null ? new Base[0] : new Base[] {this.service}; // Coding
+ case -615513385: /*modifier*/ return this.modifier == null ? new Base[0] : this.modifier.toArray(new Base[this.modifier.size()]); // Coding
case 1010065041: /*programCode*/ return this.programCode == null ? new Base[0] : this.programCode.toArray(new Base[this.programCode.size()]); // Coding
case -1285004149: /*quantity*/ return this.quantity == null ? new Base[0] : new Base[] {this.quantity}; // SimpleQuantity
case -486196699: /*unitPrice*/ return this.unitPrice == null ? new Base[0] : new Base[] {this.unitPrice}; // Money
@@ -5429,12 +5940,18 @@ public class Claim extends DomainResource {
case 1349547969: // sequence
this.sequence = castToPositiveInt(value); // PositiveIntType
break;
- case 3575610: // type
- this.type = castToCoding(value); // Coding
+ case 1099842588: // revenue
+ this.revenue = castToCoding(value); // Coding
+ break;
+ case 50511102: // category
+ this.category = castToCoding(value); // Coding
break;
case 1984153269: // service
this.service = castToCoding(value); // Coding
break;
+ case -615513385: // modifier
+ this.getModifier().add(castToCoding(value)); // Coding
+ break;
case 1010065041: // programCode
this.getProgramCode().add(castToCoding(value)); // Coding
break;
@@ -5465,10 +5982,14 @@ public class Claim extends DomainResource {
public void setProperty(String name, Base value) throws FHIRException {
if (name.equals("sequence"))
this.sequence = castToPositiveInt(value); // PositiveIntType
- else if (name.equals("type"))
- this.type = castToCoding(value); // Coding
+ else if (name.equals("revenue"))
+ this.revenue = castToCoding(value); // Coding
+ else if (name.equals("category"))
+ this.category = castToCoding(value); // Coding
else if (name.equals("service"))
this.service = castToCoding(value); // Coding
+ else if (name.equals("modifier"))
+ this.getModifier().add(castToCoding(value));
else if (name.equals("programCode"))
this.getProgramCode().add(castToCoding(value));
else if (name.equals("quantity"))
@@ -5491,8 +6012,10 @@ public class Claim extends DomainResource {
public Base makeProperty(int hash, String name) throws FHIRException {
switch (hash) {
case 1349547969: throw new FHIRException("Cannot make property sequence as it is not a complex type"); // PositiveIntType
- case 3575610: return getType(); // Coding
+ case 1099842588: return getRevenue(); // Coding
+ case 50511102: return getCategory(); // Coding
case 1984153269: return getService(); // Coding
+ case -615513385: return addModifier(); // Coding
case 1010065041: return addProgramCode(); // Coding
case -1285004149: return getQuantity(); // SimpleQuantity
case -486196699: return getUnitPrice(); // Money
@@ -5510,14 +6033,21 @@ public class Claim extends DomainResource {
if (name.equals("sequence")) {
throw new FHIRException("Cannot call addChild on a primitive type Claim.sequence");
}
- else if (name.equals("type")) {
- this.type = new Coding();
- return this.type;
+ else if (name.equals("revenue")) {
+ this.revenue = new Coding();
+ return this.revenue;
+ }
+ else if (name.equals("category")) {
+ this.category = new Coding();
+ return this.category;
}
else if (name.equals("service")) {
this.service = new Coding();
return this.service;
}
+ else if (name.equals("modifier")) {
+ return addModifier();
+ }
else if (name.equals("programCode")) {
return addProgramCode();
}
@@ -5550,8 +6080,14 @@ public class Claim extends DomainResource {
SubDetailComponent dst = new SubDetailComponent();
copyValues(dst);
dst.sequence = sequence == null ? null : sequence.copy();
- dst.type = type == null ? null : type.copy();
+ dst.revenue = revenue == null ? null : revenue.copy();
+ dst.category = category == null ? null : category.copy();
dst.service = service == null ? null : service.copy();
+ if (modifier != null) {
+ dst.modifier = new ArrayList();
+ for (Coding i : modifier)
+ dst.modifier.add(i.copy());
+ };
if (programCode != null) {
dst.programCode = new ArrayList();
for (Coding i : programCode)
@@ -5577,10 +6113,11 @@ public class Claim extends DomainResource {
if (!(other instanceof SubDetailComponent))
return false;
SubDetailComponent o = (SubDetailComponent) other;
- return compareDeep(sequence, o.sequence, true) && compareDeep(type, o.type, true) && compareDeep(service, o.service, true)
- && compareDeep(programCode, o.programCode, true) && compareDeep(quantity, o.quantity, true) && compareDeep(unitPrice, o.unitPrice, true)
- && compareDeep(factor, o.factor, true) && compareDeep(points, o.points, true) && compareDeep(net, o.net, true)
- && compareDeep(udi, o.udi, true);
+ return compareDeep(sequence, o.sequence, true) && compareDeep(revenue, o.revenue, true) && compareDeep(category, o.category, true)
+ && compareDeep(service, o.service, true) && compareDeep(modifier, o.modifier, true) && compareDeep(programCode, o.programCode, true)
+ && compareDeep(quantity, o.quantity, true) && compareDeep(unitPrice, o.unitPrice, true) && compareDeep(factor, o.factor, true)
+ && compareDeep(points, o.points, true) && compareDeep(net, o.net, true) && compareDeep(udi, o.udi, true)
+ ;
}
@Override
@@ -5595,8 +6132,9 @@ public class Claim extends DomainResource {
}
public boolean isEmpty() {
- return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(sequence, type, service
- , programCode, quantity, unitPrice, factor, points, net, udi);
+ return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(sequence, revenue, category
+ , service, modifier, programCode, quantity, unitPrice, factor, points, net, udi
+ );
}
public String fhirType() {
@@ -5611,22 +6149,23 @@ public class Claim extends DomainResource {
/**
* Indicates whether this is the initial placement of a fixed prosthesis.
*/
- @Child(name = "initial", type = {BooleanType.class}, order=1, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "initial", type = {BooleanType.class}, order=1, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Is this the initial service", formalDefinition="Indicates whether this is the initial placement of a fixed prosthesis." )
protected BooleanType initial;
/**
* Date of the initial placement.
*/
- @Child(name = "priorDate", type = {DateType.class}, order=2, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "priorDate", type = {DateType.class}, order=2, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Initial service Date", formalDefinition="Date of the initial placement." )
protected DateType priorDate;
/**
* Material of the prior denture or bridge prosthesis. (Oral).
*/
- @Child(name = "priorMaterial", type = {Coding.class}, order=3, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "priorMaterial", type = {Coding.class}, order=3, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Prosthetic Material", formalDefinition="Material of the prior denture or bridge prosthesis. (Oral)." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/oral-prosthodontic-material")
protected Coding priorMaterial;
private static final long serialVersionUID = 1739349641L;
@@ -5872,196 +6411,495 @@ public class Claim extends DomainResource {
}
- /**
- * The category of claim.
- */
- @Child(name = "type", type = {CodeType.class}, order=0, min=1, max=1, modifier=false, summary=true)
- @Description(shortDefinition="institutional | oral | pharmacy | professional | vision", formalDefinition="The category of claim." )
- protected Enumeration type;
+ @Block()
+ public static class MissingTeethComponent extends BackboneElement implements IBaseBackboneElement {
+ /**
+ * The code identifying which tooth is missing.
+ */
+ @Child(name = "tooth", type = {Coding.class}, order=1, min=1, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Tooth Code", formalDefinition="The code identifying which tooth is missing." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/teeth")
+ protected Coding tooth;
+
+ /**
+ * Missing reason may be: E-extraction, O-other.
+ */
+ @Child(name = "reason", type = {Coding.class}, order=2, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Indicates whether it was extracted or other reason", formalDefinition="Missing reason may be: E-extraction, O-other." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/missing-tooth-reason")
+ protected Coding reason;
+
+ /**
+ * The date of the extraction either known from records or patient reported estimate.
+ */
+ @Child(name = "extractionDate", type = {DateType.class}, order=3, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Date tooth was extracted if known", formalDefinition="The date of the extraction either known from records or patient reported estimate." )
+ protected DateType extractionDate;
+
+ private static final long serialVersionUID = 352913313L;
/**
- * A finer grained suite of claim subtype codes which may convey Inpatient vs Outpatient and/or a specialty service. In the US the BillType.
+ * Constructor
*/
- @Child(name = "subType", type = {Coding.class}, order=1, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
- @Description(shortDefinition="Finer grained claim type information", formalDefinition="A finer grained suite of claim subtype codes which may convey Inpatient vs Outpatient and/or a specialty service. In the US the BillType." )
- protected List subType;
+ public MissingTeethComponent() {
+ super();
+ }
+
+ /**
+ * Constructor
+ */
+ public MissingTeethComponent(Coding tooth) {
+ super();
+ this.tooth = tooth;
+ }
+
+ /**
+ * @return {@link #tooth} (The code identifying which tooth is missing.)
+ */
+ public Coding getTooth() {
+ if (this.tooth == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create MissingTeethComponent.tooth");
+ else if (Configuration.doAutoCreate())
+ this.tooth = new Coding(); // cc
+ return this.tooth;
+ }
+
+ public boolean hasTooth() {
+ return this.tooth != null && !this.tooth.isEmpty();
+ }
+
+ /**
+ * @param value {@link #tooth} (The code identifying which tooth is missing.)
+ */
+ public MissingTeethComponent setTooth(Coding value) {
+ this.tooth = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #reason} (Missing reason may be: E-extraction, O-other.)
+ */
+ public Coding getReason() {
+ if (this.reason == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create MissingTeethComponent.reason");
+ else if (Configuration.doAutoCreate())
+ this.reason = new Coding(); // cc
+ return this.reason;
+ }
+
+ public boolean hasReason() {
+ return this.reason != null && !this.reason.isEmpty();
+ }
+
+ /**
+ * @param value {@link #reason} (Missing reason may be: E-extraction, O-other.)
+ */
+ public MissingTeethComponent setReason(Coding value) {
+ this.reason = value;
+ return this;
+ }
+
+ /**
+ * @return {@link #extractionDate} (The date of the extraction either known from records or patient reported estimate.). This is the underlying object with id, value and extensions. The accessor "getExtractionDate" gives direct access to the value
+ */
+ public DateType getExtractionDateElement() {
+ if (this.extractionDate == null)
+ if (Configuration.errorOnAutoCreate())
+ throw new Error("Attempt to auto-create MissingTeethComponent.extractionDate");
+ else if (Configuration.doAutoCreate())
+ this.extractionDate = new DateType(); // bb
+ return this.extractionDate;
+ }
+
+ public boolean hasExtractionDateElement() {
+ return this.extractionDate != null && !this.extractionDate.isEmpty();
+ }
+
+ public boolean hasExtractionDate() {
+ return this.extractionDate != null && !this.extractionDate.isEmpty();
+ }
+
+ /**
+ * @param value {@link #extractionDate} (The date of the extraction either known from records or patient reported estimate.). This is the underlying object with id, value and extensions. The accessor "getExtractionDate" gives direct access to the value
+ */
+ public MissingTeethComponent setExtractionDateElement(DateType value) {
+ this.extractionDate = value;
+ return this;
+ }
+
+ /**
+ * @return The date of the extraction either known from records or patient reported estimate.
+ */
+ public Date getExtractionDate() {
+ return this.extractionDate == null ? null : this.extractionDate.getValue();
+ }
+
+ /**
+ * @param value The date of the extraction either known from records or patient reported estimate.
+ */
+ public MissingTeethComponent setExtractionDate(Date value) {
+ if (value == null)
+ this.extractionDate = null;
+ else {
+ if (this.extractionDate == null)
+ this.extractionDate = new DateType();
+ this.extractionDate.setValue(value);
+ }
+ return this;
+ }
+
+ protected void listChildren(List childrenList) {
+ super.listChildren(childrenList);
+ childrenList.add(new Property("tooth", "Coding", "The code identifying which tooth is missing.", 0, java.lang.Integer.MAX_VALUE, tooth));
+ childrenList.add(new Property("reason", "Coding", "Missing reason may be: E-extraction, O-other.", 0, java.lang.Integer.MAX_VALUE, reason));
+ childrenList.add(new Property("extractionDate", "date", "The date of the extraction either known from records or patient reported estimate.", 0, java.lang.Integer.MAX_VALUE, extractionDate));
+ }
+
+ @Override
+ public Base[] getProperty(int hash, String name, boolean checkValid) throws FHIRException {
+ switch (hash) {
+ case 110545608: /*tooth*/ return this.tooth == null ? new Base[0] : new Base[] {this.tooth}; // Coding
+ case -934964668: /*reason*/ return this.reason == null ? new Base[0] : new Base[] {this.reason}; // Coding
+ case 580646965: /*extractionDate*/ return this.extractionDate == null ? new Base[0] : new Base[] {this.extractionDate}; // DateType
+ default: return super.getProperty(hash, name, checkValid);
+ }
+
+ }
+
+ @Override
+ public void setProperty(int hash, String name, Base value) throws FHIRException {
+ switch (hash) {
+ case 110545608: // tooth
+ this.tooth = castToCoding(value); // Coding
+ break;
+ case -934964668: // reason
+ this.reason = castToCoding(value); // Coding
+ break;
+ case 580646965: // extractionDate
+ this.extractionDate = castToDate(value); // DateType
+ break;
+ default: super.setProperty(hash, name, value);
+ }
+
+ }
+
+ @Override
+ public void setProperty(String name, Base value) throws FHIRException {
+ if (name.equals("tooth"))
+ this.tooth = castToCoding(value); // Coding
+ else if (name.equals("reason"))
+ this.reason = castToCoding(value); // Coding
+ else if (name.equals("extractionDate"))
+ this.extractionDate = castToDate(value); // DateType
+ else
+ super.setProperty(name, value);
+ }
+
+ @Override
+ public Base makeProperty(int hash, String name) throws FHIRException {
+ switch (hash) {
+ case 110545608: return getTooth(); // Coding
+ case -934964668: return getReason(); // Coding
+ case 580646965: throw new FHIRException("Cannot make property extractionDate as it is not a complex type"); // DateType
+ default: return super.makeProperty(hash, name);
+ }
+
+ }
+
+ @Override
+ public Base addChild(String name) throws FHIRException {
+ if (name.equals("tooth")) {
+ this.tooth = new Coding();
+ return this.tooth;
+ }
+ else if (name.equals("reason")) {
+ this.reason = new Coding();
+ return this.reason;
+ }
+ else if (name.equals("extractionDate")) {
+ throw new FHIRException("Cannot call addChild on a primitive type Claim.extractionDate");
+ }
+ else
+ return super.addChild(name);
+ }
+
+ public MissingTeethComponent copy() {
+ MissingTeethComponent dst = new MissingTeethComponent();
+ copyValues(dst);
+ dst.tooth = tooth == null ? null : tooth.copy();
+ dst.reason = reason == null ? null : reason.copy();
+ dst.extractionDate = extractionDate == null ? null : extractionDate.copy();
+ return dst;
+ }
+
+ @Override
+ public boolean equalsDeep(Base other) {
+ if (!super.equalsDeep(other))
+ return false;
+ if (!(other instanceof MissingTeethComponent))
+ return false;
+ MissingTeethComponent o = (MissingTeethComponent) other;
+ return compareDeep(tooth, o.tooth, true) && compareDeep(reason, o.reason, true) && compareDeep(extractionDate, o.extractionDate, true)
+ ;
+ }
+
+ @Override
+ public boolean equalsShallow(Base other) {
+ if (!super.equalsShallow(other))
+ return false;
+ if (!(other instanceof MissingTeethComponent))
+ return false;
+ MissingTeethComponent o = (MissingTeethComponent) other;
+ return compareValues(extractionDate, o.extractionDate, true);
+ }
+
+ public boolean isEmpty() {
+ return super.isEmpty() && ca.uhn.fhir.util.ElementUtil.isEmpty(tooth, reason, extractionDate
+ );
+ }
+
+ public String fhirType() {
+ return "Claim.missingTeeth";
+
+ }
+
+ }
/**
* The business identifier for the instance: claim number, pre-determination or pre-authorization number.
*/
- @Child(name = "identifier", type = {Identifier.class}, order=2, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=true)
+ @Child(name = "identifier", type = {Identifier.class}, order=0, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
@Description(shortDefinition="Claim number", formalDefinition="The business identifier for the instance: claim number, pre-determination or pre-authorization number." )
protected List identifier;
+ /**
+ * The status of the resource instance.
+ */
+ @Child(name = "status", type = {CodeType.class}, order=1, min=1, max=1, modifier=true, summary=true)
+ @Description(shortDefinition="active | cancelled | draft | entered-in-error", formalDefinition="The status of the resource instance." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/claim-status")
+ protected Enumeration status;
+
+ /**
+ * The category of claim, eg, oral, pharmacy, vision, insitutional, professional.
+ */
+ @Child(name = "type", type = {Coding.class}, order=2, min=1, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Type or discipline", formalDefinition="The category of claim, eg, oral, pharmacy, vision, insitutional, professional." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/claim-type")
+ protected Coding type;
+
+ /**
+ * A finer grained suite of claim subtype codes which may convey Inpatient vs Outpatient and/or a specialty service. In the US the BillType.
+ */
+ @Child(name = "subType", type = {Coding.class}, order=3, min=0, max=Child.MAX_UNLIMITED, modifier=false, summary=false)
+ @Description(shortDefinition="Finer grained claim type information", formalDefinition="A finer grained suite of claim subtype codes which may convey Inpatient vs Outpatient and/or a specialty service. In the US the BillType." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/claim-subtype")
+ protected List subType;
+
/**
* The version of the specification on which this instance relies.
*/
- @Child(name = "ruleset", type = {Coding.class}, order=3, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "ruleset", type = {Coding.class}, order=4, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Current specification followed", formalDefinition="The version of the specification on which this instance relies." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/ruleset")
protected Coding ruleset;
/**
* The version of the specification from which the original instance was created.
*/
- @Child(name = "originalRuleset", type = {Coding.class}, order=4, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "originalRuleset", type = {Coding.class}, order=5, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Original specification followed", formalDefinition="The version of the specification from which the original instance was created." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/ruleset")
protected Coding originalRuleset;
/**
* The date when the enclosed suite of services were performed or completed.
*/
- @Child(name = "created", type = {DateTimeType.class}, order=5, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "created", type = {DateTimeType.class}, order=6, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Creation date", formalDefinition="The date when the enclosed suite of services were performed or completed." )
protected DateTimeType created;
/**
* The billable period for which charges are being submitted.
*/
- @Child(name = "billablePeriod", type = {Period.class}, order=6, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "billablePeriod", type = {Period.class}, order=7, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Period for charge submission", formalDefinition="The billable period for which charges are being submitted." )
protected Period billablePeriod;
/**
- * Insurer Identifier, typical BIN number (6 digit).
+ * The Insurer who is target of the request.
*/
- @Child(name = "target", type = {Identifier.class, Organization.class}, order=7, min=0, max=1, modifier=false, summary=true)
- @Description(shortDefinition="Insurer", formalDefinition="Insurer Identifier, typical BIN number (6 digit)." )
- protected Type target;
+ @Child(name = "insurer", type = {Identifier.class, Organization.class}, order=8, min=0, max=1, modifier=false, summary=false)
+ @Description(shortDefinition="Target", formalDefinition="The Insurer who is target of the request." )
+ protected Type insurer;
/**
* The provider which is responsible for the bill, claim pre-determination, pre-authorization.
*/
- @Child(name = "provider", type = {Identifier.class, Practitioner.class}, order=8, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "provider", type = {Identifier.class, Practitioner.class}, order=9, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Responsible provider", formalDefinition="The provider which is responsible for the bill, claim pre-determination, pre-authorization." )
protected Type provider;
/**
* The organization which is responsible for the bill, claim pre-determination, pre-authorization.
*/
- @Child(name = "organization", type = {Identifier.class, Organization.class}, order=9, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "organization", type = {Identifier.class, Organization.class}, order=10, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="Responsible organization", formalDefinition="The organization which is responsible for the bill, claim pre-determination, pre-authorization." )
protected Type organization;
/**
* Complete (Bill or Claim), Proposed (Pre-Authorization), Exploratory (Pre-determination).
*/
- @Child(name = "use", type = {CodeType.class}, order=10, min=0, max=1, modifier=false, summary=true)
+ @Child(name = "use", type = {CodeType.class}, order=11, min=0, max=1, modifier=false, summary=false)
@Description(shortDefinition="complete | proposed | exploratory | other", formalDefinition="Complete (Bill or Claim), Proposed (Pre-Authorization), Exploratory (Pre-determination)." )
+ @ca.uhn.fhir.model.api.annotation.Binding(valueSet="http://hl7.org/fhir/ValueSet/claim-use")
protected Enumeration