Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
package org.hl7.fhir.r5.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 Thu, Mar 23, 2023 19:59+1100 for FHIR v5.0.0
import org.hl7.fhir.instance.model.api.*;
import org.hl7.fhir.utilities.Utilities;
import org.hl7.fhir.exceptions.FHIRException;
public class Enumerations {
// In here:
// ActionCardinalityBehavior: Defines behavior for an action or a group for how many times that item may be repeated.[PlanDefinition, RequestOrchestration]
// ActionConditionKind: Defines the kinds of conditions that can appear on actions.[PlanDefinition, RequestOrchestration]
// ActionGroupingBehavior: Defines organization behavior of a group.[PlanDefinition, RequestOrchestration]
// ActionParticipantType: The type of participant for the action.[ActivityDefinition, PlanDefinition, RequestOrchestration]
// ActionPrecheckBehavior: Defines selection frequency behavior for an action or group.[PlanDefinition, RequestOrchestration]
// ActionRelationshipType: Defines the types of relationships between actions.[PlanDefinition, RequestOrchestration]
// ActionRequiredBehavior: Defines expectations around whether an action or action group is required.[PlanDefinition, RequestOrchestration]
// ActionSelectionBehavior: Defines selection behavior of a group.[PlanDefinition, RequestOrchestration]
// AdministrativeGender: The gender of a person used for administrative purposes.[ObservationDefinition, Patient, Person, Practitioner, RelatedPerson]
// AllLanguages: This value set includes all possible codes from BCP-47 (see http://tools.ietf.org/html/bcp47)[Account, ActivityDefinition, ActorDefinition, AdministrableProductDefinition, AdverseEvent, AllergyIntolerance, Appointment, AppointmentResponse, ArtifactAssessment, Attachment, AuditEvent, Basic, Binary, BiologicallyDerivedProduct, BiologicallyDerivedProductDispense, BodyStructure, Bundle, CanonicalResource, CapabilityStatement, CarePlan, CareTeam, ChargeItem, ChargeItemDefinition, Citation, Claim, ClaimResponse, ClinicalImpression, ClinicalUseDefinition, CodeSystem, Communication, CommunicationRequest, CompartmentDefinition, Composition, ConceptMap, Condition, ConditionDefinition, Consent, Contract, Coverage, CoverageEligibilityRequest, CoverageEligibilityResponse, DetectedIssue, Device, DeviceAssociation, DeviceDefinition, DeviceDispense, DeviceMetric, DeviceRequest, DeviceUsage, DiagnosticReport, DocumentReference, DomainResource, Encounter, EncounterHistory, Endpoint, EnrollmentRequest, EnrollmentResponse, EpisodeOfCare, EventDefinition, Evidence, EvidenceReport, EvidenceVariable, ExampleScenario, ExplanationOfBenefit, FamilyMemberHistory, Flag, FormularyItem, GenomicStudy, Goal, GraphDefinition, Group, GuidanceResponse, HealthcareService, ImagingSelection, ImagingStudy, Immunization, ImmunizationEvaluation, ImmunizationRecommendation, ImplementationGuide, Ingredient, InsurancePlan, InventoryItem, InventoryReport, Invoice, Library, Linkage, List, Location, ManufacturedItemDefinition, Measure, MeasureReport, Medication, MedicationAdministration, MedicationDispense, MedicationKnowledge, MedicationRequest, MedicationStatement, MedicinalProductDefinition, MessageDefinition, MessageHeader, MetadataResource, MolecularSequence, NamingSystem, NutritionIntake, NutritionOrder, NutritionProduct, Observation, ObservationDefinition, OperationDefinition, OperationOutcome, Organization, OrganizationAffiliation, PackagedProductDefinition, Parameters, Patient, PaymentNotice, PaymentReconciliation, Permission, Person, PlanDefinition, Practitioner, PractitionerRole, Procedure, Provenance, Questionnaire, QuestionnaireResponse, RegulatedAuthorization, RelatedPerson, RequestOrchestration, Requirements, ResearchStudy, ResearchSubject, Resource, RiskAssessment, Schedule, SearchParameter, ServiceRequest, Slot, Specimen, SpecimenDefinition, StructureDefinition, StructureMap, Subscription, SubscriptionStatus, SubscriptionTopic, Substance, SubstanceDefinition, SubstanceNucleicAcid, SubstancePolymer, SubstanceProtein, SubstanceReferenceInformation, SubstanceSourceMaterial, SupplyDelivery, SupplyRequest, Task, TerminologyCapabilities, TestPlan, TestReport, TestScript, Transport, ValueSet, VerificationResult, VisionPrescription]
// BindingStrength: Indication of the degree of conformance expectations associated with a binding.[ElementDefinition, OperationDefinition]
// CapabilityStatementKind: How a capability statement is intended to be used.[CapabilityStatement, TerminologyCapabilities]
// ClaimProcessingCodes: This value set includes Claim Processing Outcome codes.[ClaimResponse, ExplanationOfBenefit]
// CodeSystemContentMode: The extent of the content of the code system (the concepts and codes it defines) are represented in a code system resource.[CodeSystem, TerminologyCapabilities]
// CommonLanguages: This value set includes common codes from BCP-47 (see http://tools.ietf.org/html/bcp47)[InventoryItem, TerminologyCapabilities]
// CompartmentType: Which type a compartment definition describes.[CompartmentDefinition, GraphDefinition]
// CompositionStatus: The workflow/clinical status of the composition.[Composition, DocumentReference]
// ConceptMapRelationship: The relationship between concepts.[ConceptMap]
// ConsentDataMeaning: How a resource reference is interpreted when testing consent restrictions.[Consent, Permission]
// ConsentProvisionType: How a rule statement is applied, such as adding additional consent or removing consent.[Consent, Permission]
// Currencies: Currency codes from ISO 4217 (see https://www.iso.org/iso-4217-currency-codes.html)[Account, Money]
// DaysOfWeek: The days of the week.[Appointment, Availability, Timing]
// DeviceNameType: The type of name the device is referred by.[Device, DeviceDefinition]
// EncounterStatus: Current state of the encounter.[Encounter, EncounterHistory]
// EventStatus: Codes identifying the lifecycle stage of an event.[ClinicalImpression, Communication, NutritionIntake, Procedure]
// EvidenceVariableHandling: The handling of the variable in statistical analysis for exposures or outcomes (E.g. Dichotomous, Continuous, Descriptive).[Evidence, EvidenceVariable]
// ExampleScenarioActorType: The type of actor - system or human.[ActorDefinition, ExampleScenario]
// FHIRTypes: All FHIR types[DataRequirement, Measure, OperationDefinition, ParameterDefinition]
// FHIRVersion: All published FHIR Versions.[CapabilityStatement, ImplementationGuide, StructureDefinition]
// FilterOperator: The kind of operation to perform as a part of a property based filter.[CodeSystem, ValueSet]
// FinancialResourceStatusCodes: This value set includes Status codes.[Claim, ClaimResponse, Coverage, CoverageEligibilityRequest, CoverageEligibilityResponse, EnrollmentRequest, EnrollmentResponse, PaymentNotice, PaymentReconciliation, VisionPrescription]
// ListMode: The processing mode that applies to this list.[EvidenceReport, List]
// MeasureImprovementNotation: Observation values that indicate what change in a measurement value or score is indicative of an improvement in the measured item or scored issue.[Measure, MeasureReport]
// MimeTypes: This value set includes all possible codes from BCP-13 (see http://tools.ietf.org/html/bcp13)[Attachment, Binary, CapabilityStatement, ElementDefinition, Endpoint, Signature, Subscription, TestScript]
// ObservationStatus: Codes providing the status of an observation.[Observation, RiskAssessment]
// OperationParameterUse: Whether an operation parameter is an input or an output parameter.[OperationDefinition, ParameterDefinition]
// PublicationStatus: The lifecycle status of an artifact.[ActivityDefinition, ActorDefinition, AdministrableProductDefinition, CanonicalResource, CapabilityStatement, ChargeItemDefinition, Citation, CodeSystem, CompartmentDefinition, ConceptMap, ConditionDefinition, EventDefinition, Evidence, EvidenceReport, EvidenceVariable, ExampleScenario, GraphDefinition, ImplementationGuide, Ingredient, InsurancePlan, Library, ManufacturedItemDefinition, Measure, MessageDefinition, MetadataResource, NamingSystem, ObservationDefinition, OperationDefinition, PlanDefinition, Questionnaire, RelatedArtifact, Requirements, ResearchStudy, ResearchSubject, SearchParameter, SpecimenDefinition, StructureDefinition, StructureMap, SubscriptionTopic, TerminologyCapabilities, TestPlan, TestScript, ValueSet]
// QuantityComparator: How the Quantity should be understood and represented.[Age, Count, Distance, Duration, Quantity]
// RequestIntent: Codes indicating the degree of authority/intentionality associated with a request.[ActivityDefinition, CommunicationRequest, DeviceRequest, NutritionOrder, RequestOrchestration, ServiceRequest]
// RequestPriority: Identifies the level of importance to be assigned to actioning the request.[ActivityDefinition, Communication, CommunicationRequest, DeviceRequest, MedicationRequest, NutritionOrder, PlanDefinition, RequestOrchestration, ServiceRequest, SupplyRequest, Task, Transport]
// RequestStatus: Codes identifying the lifecycle stage of a request.[CarePlan, CommunicationRequest, DeviceRequest, NutritionOrder, RequestOrchestration, ServiceRequest]
// ResourceTypeEnum: Concrete FHIR Resource Types[CapabilityStatement, CompartmentDefinition, ImplementationGuide, MessageDefinition, Questionnaire]
// SearchComparator: What Search Comparator Codes are supported in search.[SearchParameter, Subscription, SubscriptionTopic]
// SearchModifierCode: A supported modifier for a search parameter.[SearchParameter, Subscription, SubscriptionTopic]
// SearchParamType: Data types allowed to be used for search parameters.[CapabilityStatement, OperationDefinition, SearchParameter]
// SubscriptionStatusCodes: State values for FHIR Subscriptions.[Subscription, SubscriptionStatus]
// Use: The purpose of the Claim: predetermination, preauthorization, claim.[Claim, ClaimResponse, ExplanationOfBenefit]
// VersionIndependentResourceTypesAll: Current and past FHIR resource types (deleted or renamed), including abstract types[GraphDefinition, OperationDefinition, SearchParameter]
public enum ActionCardinalityBehavior {
/**
* The action may only be selected one time.
*/
SINGLE,
/**
* The action may be selected multiple times.
*/
MULTIPLE,
/**
* added to help the parsers
*/
NULL;
public static ActionCardinalityBehavior fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("single".equals(codeString))
return SINGLE;
if ("multiple".equals(codeString))
return MULTIPLE;
throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "single", "multiple");
}
public String toCode() {
switch (this) {
case SINGLE: return "single";
case MULTIPLE: return "multiple";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case SINGLE: return "http://hl7.org/fhir/action-cardinality-behavior";
case MULTIPLE: return "http://hl7.org/fhir/action-cardinality-behavior";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case SINGLE: return "The action may only be selected one time.";
case MULTIPLE: return "The action may be selected multiple times.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case SINGLE: return "Single";
case MULTIPLE: return "Multiple";
case NULL: return null;
default: return "?";
}
}
}
public static class ActionCardinalityBehaviorEnumFactory implements EnumFactory {
public ActionCardinalityBehavior fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("single".equals(codeString))
return ActionCardinalityBehavior.SINGLE;
if ("multiple".equals(codeString))
return ActionCardinalityBehavior.MULTIPLE;
throw new IllegalArgumentException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ActionCardinalityBehavior.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ActionCardinalityBehavior.NULL, code);
if ("single".equals(codeString))
return new Enumeration(this, ActionCardinalityBehavior.SINGLE, code);
if ("multiple".equals(codeString))
return new Enumeration(this, ActionCardinalityBehavior.MULTIPLE, code);
throw new FHIRException("Unknown ActionCardinalityBehavior code '"+codeString+"'");
}
public String toCode(ActionCardinalityBehavior code) {
if (code == ActionCardinalityBehavior.NULL)
return null;
if (code == ActionCardinalityBehavior.SINGLE)
return "single";
if (code == ActionCardinalityBehavior.MULTIPLE)
return "multiple";
return "?";
}
public String toSystem(ActionCardinalityBehavior code) {
return code.getSystem();
}
}
public enum ActionConditionKind {
/**
* The condition describes whether or not a given action is applicable.
*/
APPLICABILITY,
/**
* The condition is a starting condition for the action.
*/
START,
/**
* The condition is a stop, or exit condition for the action.
*/
STOP,
/**
* added to help the parsers
*/
NULL;
public static ActionConditionKind fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("applicability".equals(codeString))
return APPLICABILITY;
if ("start".equals(codeString))
return START;
if ("stop".equals(codeString))
return STOP;
throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "applicability", "start", "stop");
}
public String toCode() {
switch (this) {
case APPLICABILITY: return "applicability";
case START: return "start";
case STOP: return "stop";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case APPLICABILITY: return "http://hl7.org/fhir/action-condition-kind";
case START: return "http://hl7.org/fhir/action-condition-kind";
case STOP: return "http://hl7.org/fhir/action-condition-kind";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case APPLICABILITY: return "The condition describes whether or not a given action is applicable.";
case START: return "The condition is a starting condition for the action.";
case STOP: return "The condition is a stop, or exit condition for the action.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case APPLICABILITY: return "Applicability";
case START: return "Start";
case STOP: return "Stop";
case NULL: return null;
default: return "?";
}
}
}
public static class ActionConditionKindEnumFactory implements EnumFactory {
public ActionConditionKind fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("applicability".equals(codeString))
return ActionConditionKind.APPLICABILITY;
if ("start".equals(codeString))
return ActionConditionKind.START;
if ("stop".equals(codeString))
return ActionConditionKind.STOP;
throw new IllegalArgumentException("Unknown ActionConditionKind code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ActionConditionKind.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ActionConditionKind.NULL, code);
if ("applicability".equals(codeString))
return new Enumeration(this, ActionConditionKind.APPLICABILITY, code);
if ("start".equals(codeString))
return new Enumeration(this, ActionConditionKind.START, code);
if ("stop".equals(codeString))
return new Enumeration(this, ActionConditionKind.STOP, code);
throw new FHIRException("Unknown ActionConditionKind code '"+codeString+"'");
}
public String toCode(ActionConditionKind code) {
if (code == ActionConditionKind.NULL)
return null;
if (code == ActionConditionKind.APPLICABILITY)
return "applicability";
if (code == ActionConditionKind.START)
return "start";
if (code == ActionConditionKind.STOP)
return "stop";
return "?";
}
public String toSystem(ActionConditionKind code) {
return code.getSystem();
}
}
public enum ActionGroupingBehavior {
/**
* Any group marked with this behavior should be displayed as a visual group to the end user.
*/
VISUALGROUP,
/**
* A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so.
*/
LOGICALGROUP,
/**
* A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are "aspirin, 500 mg, 2 times per day" and "aspirin, 300 mg, 3 times per day". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of "AtMostOne", unless it's a required action, in which case, it would be "ExactlyOne".
*/
SENTENCEGROUP,
/**
* added to help the parsers
*/
NULL;
public static ActionGroupingBehavior fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("visual-group".equals(codeString))
return VISUALGROUP;
if ("logical-group".equals(codeString))
return LOGICALGROUP;
if ("sentence-group".equals(codeString))
return SENTENCEGROUP;
throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "visual-group", "logical-group", "sentence-group");
}
public String toCode() {
switch (this) {
case VISUALGROUP: return "visual-group";
case LOGICALGROUP: return "logical-group";
case SENTENCEGROUP: return "sentence-group";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case VISUALGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
case LOGICALGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
case SENTENCEGROUP: return "http://hl7.org/fhir/action-grouping-behavior";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case VISUALGROUP: return "Any group marked with this behavior should be displayed as a visual group to the end user.";
case LOGICALGROUP: return "A group with this behavior logically groups its sub-elements, and may be shown as a visual group to the end user, but it is not required to do so.";
case SENTENCEGROUP: return "A group of related alternative actions is a sentence group if the target referenced by the action is the same in all the actions and each action simply constitutes a different variation on how to specify the details for the target. For example, two actions that could be in a SentenceGroup are \"aspirin, 500 mg, 2 times per day\" and \"aspirin, 300 mg, 3 times per day\". In both cases, aspirin is the target referenced by the action, and the two actions represent different options for how aspirin might be ordered for the patient. Note that a SentenceGroup would almost always have an associated selection behavior of \"AtMostOne\", unless it's a required action, in which case, it would be \"ExactlyOne\".";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case VISUALGROUP: return "Visual Group";
case LOGICALGROUP: return "Logical Group";
case SENTENCEGROUP: return "Sentence Group";
case NULL: return null;
default: return "?";
}
}
}
public static class ActionGroupingBehaviorEnumFactory implements EnumFactory {
public ActionGroupingBehavior fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("visual-group".equals(codeString))
return ActionGroupingBehavior.VISUALGROUP;
if ("logical-group".equals(codeString))
return ActionGroupingBehavior.LOGICALGROUP;
if ("sentence-group".equals(codeString))
return ActionGroupingBehavior.SENTENCEGROUP;
throw new IllegalArgumentException("Unknown ActionGroupingBehavior code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ActionGroupingBehavior.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ActionGroupingBehavior.NULL, code);
if ("visual-group".equals(codeString))
return new Enumeration(this, ActionGroupingBehavior.VISUALGROUP, code);
if ("logical-group".equals(codeString))
return new Enumeration(this, ActionGroupingBehavior.LOGICALGROUP, code);
if ("sentence-group".equals(codeString))
return new Enumeration(this, ActionGroupingBehavior.SENTENCEGROUP, code);
throw new FHIRException("Unknown ActionGroupingBehavior code '"+codeString+"'");
}
public String toCode(ActionGroupingBehavior code) {
if (code == ActionGroupingBehavior.NULL)
return null;
if (code == ActionGroupingBehavior.VISUALGROUP)
return "visual-group";
if (code == ActionGroupingBehavior.LOGICALGROUP)
return "logical-group";
if (code == ActionGroupingBehavior.SENTENCEGROUP)
return "sentence-group";
return "?";
}
public String toSystem(ActionGroupingBehavior code) {
return code.getSystem();
}
}
public enum ActionParticipantType {
/**
* The participant is a care team caring for the patient under evaluation.
*/
CARETEAM,
/**
* The participant is a system or device used in the care of the patient.
*/
DEVICE,
/**
* The participant is a group of participants involved in the care of the patient.
*/
GROUP,
/**
* The participant is an institution that can provide the given healthcare service used in the care of the patient.
*/
HEALTHCARESERVICE,
/**
* The participant is a location involved in the care of the patient.
*/
LOCATION,
/**
* The participant is an organization involved in the care of the patient.
*/
ORGANIZATION,
/**
* The participant is the patient under evaluation.
*/
PATIENT,
/**
* The participant is a practitioner involved in the patient's care.
*/
PRACTITIONER,
/**
* The participant is a particular practitioner role involved in the patient's care.
*/
PRACTITIONERROLE,
/**
* The participant is a person related to the patient.
*/
RELATEDPERSON,
/**
* added to help the parsers
*/
NULL;
public static ActionParticipantType fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("careteam".equals(codeString))
return CARETEAM;
if ("device".equals(codeString))
return DEVICE;
if ("group".equals(codeString))
return GROUP;
if ("healthcareservice".equals(codeString))
return HEALTHCARESERVICE;
if ("location".equals(codeString))
return LOCATION;
if ("organization".equals(codeString))
return ORGANIZATION;
if ("patient".equals(codeString))
return PATIENT;
if ("practitioner".equals(codeString))
return PRACTITIONER;
if ("practitionerrole".equals(codeString))
return PRACTITIONERROLE;
if ("relatedperson".equals(codeString))
return RELATEDPERSON;
throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "careteam", "device", "group", "healthcareservice", "location", "organization", "patient", "practitioner", "practitionerrole", "relatedperson");
}
public String toCode() {
switch (this) {
case CARETEAM: return "careteam";
case DEVICE: return "device";
case GROUP: return "group";
case HEALTHCARESERVICE: return "healthcareservice";
case LOCATION: return "location";
case ORGANIZATION: return "organization";
case PATIENT: return "patient";
case PRACTITIONER: return "practitioner";
case PRACTITIONERROLE: return "practitionerrole";
case RELATEDPERSON: return "relatedperson";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case CARETEAM: return "http://hl7.org/fhir/action-participant-type";
case DEVICE: return "http://hl7.org/fhir/action-participant-type";
case GROUP: return "http://hl7.org/fhir/action-participant-type";
case HEALTHCARESERVICE: return "http://hl7.org/fhir/action-participant-type";
case LOCATION: return "http://hl7.org/fhir/action-participant-type";
case ORGANIZATION: return "http://hl7.org/fhir/action-participant-type";
case PATIENT: return "http://hl7.org/fhir/action-participant-type";
case PRACTITIONER: return "http://hl7.org/fhir/action-participant-type";
case PRACTITIONERROLE: return "http://hl7.org/fhir/action-participant-type";
case RELATEDPERSON: return "http://hl7.org/fhir/action-participant-type";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case CARETEAM: return "The participant is a care team caring for the patient under evaluation.";
case DEVICE: return "The participant is a system or device used in the care of the patient.";
case GROUP: return "The participant is a group of participants involved in the care of the patient.";
case HEALTHCARESERVICE: return "The participant is an institution that can provide the given healthcare service used in the care of the patient.";
case LOCATION: return "The participant is a location involved in the care of the patient.";
case ORGANIZATION: return "The participant is an organization involved in the care of the patient.";
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 PRACTITIONERROLE: return "The participant is a particular practitioner role involved in the patient's care.";
case RELATEDPERSON: return "The participant is a person related to the patient.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case CARETEAM: return "CareTeam";
case DEVICE: return "Device";
case GROUP: return "Group";
case HEALTHCARESERVICE: return "HealthcareService";
case LOCATION: return "Location";
case ORGANIZATION: return "Organization";
case PATIENT: return "Patient";
case PRACTITIONER: return "Practitioner";
case PRACTITIONERROLE: return "PractitionerRole";
case RELATEDPERSON: return "RelatedPerson";
case NULL: return null;
default: return "?";
}
}
}
public static class ActionParticipantTypeEnumFactory implements EnumFactory {
public ActionParticipantType fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("careteam".equals(codeString))
return ActionParticipantType.CARETEAM;
if ("device".equals(codeString))
return ActionParticipantType.DEVICE;
if ("group".equals(codeString))
return ActionParticipantType.GROUP;
if ("healthcareservice".equals(codeString))
return ActionParticipantType.HEALTHCARESERVICE;
if ("location".equals(codeString))
return ActionParticipantType.LOCATION;
if ("organization".equals(codeString))
return ActionParticipantType.ORGANIZATION;
if ("patient".equals(codeString))
return ActionParticipantType.PATIENT;
if ("practitioner".equals(codeString))
return ActionParticipantType.PRACTITIONER;
if ("practitionerrole".equals(codeString))
return ActionParticipantType.PRACTITIONERROLE;
if ("relatedperson".equals(codeString))
return ActionParticipantType.RELATEDPERSON;
throw new IllegalArgumentException("Unknown ActionParticipantType code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ActionParticipantType.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ActionParticipantType.NULL, code);
if ("careteam".equals(codeString))
return new Enumeration(this, ActionParticipantType.CARETEAM, code);
if ("device".equals(codeString))
return new Enumeration(this, ActionParticipantType.DEVICE, code);
if ("group".equals(codeString))
return new Enumeration(this, ActionParticipantType.GROUP, code);
if ("healthcareservice".equals(codeString))
return new Enumeration(this, ActionParticipantType.HEALTHCARESERVICE, code);
if ("location".equals(codeString))
return new Enumeration(this, ActionParticipantType.LOCATION, code);
if ("organization".equals(codeString))
return new Enumeration(this, ActionParticipantType.ORGANIZATION, code);
if ("patient".equals(codeString))
return new Enumeration(this, ActionParticipantType.PATIENT, code);
if ("practitioner".equals(codeString))
return new Enumeration(this, ActionParticipantType.PRACTITIONER, code);
if ("practitionerrole".equals(codeString))
return new Enumeration(this, ActionParticipantType.PRACTITIONERROLE, code);
if ("relatedperson".equals(codeString))
return new Enumeration(this, ActionParticipantType.RELATEDPERSON, code);
throw new FHIRException("Unknown ActionParticipantType code '"+codeString+"'");
}
public String toCode(ActionParticipantType code) {
if (code == ActionParticipantType.NULL)
return null;
if (code == ActionParticipantType.CARETEAM)
return "careteam";
if (code == ActionParticipantType.DEVICE)
return "device";
if (code == ActionParticipantType.GROUP)
return "group";
if (code == ActionParticipantType.HEALTHCARESERVICE)
return "healthcareservice";
if (code == ActionParticipantType.LOCATION)
return "location";
if (code == ActionParticipantType.ORGANIZATION)
return "organization";
if (code == ActionParticipantType.PATIENT)
return "patient";
if (code == ActionParticipantType.PRACTITIONER)
return "practitioner";
if (code == ActionParticipantType.PRACTITIONERROLE)
return "practitionerrole";
if (code == ActionParticipantType.RELATEDPERSON)
return "relatedperson";
return "?";
}
public String toSystem(ActionParticipantType code) {
return code.getSystem();
}
}
public enum ActionPrecheckBehavior {
/**
* An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider "pre-checking" such an action as a convenience for the user.
*/
YES,
/**
* An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not "pre-check" such an action.
*/
NO,
/**
* added to help the parsers
*/
NULL;
public static ActionPrecheckBehavior fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("yes".equals(codeString))
return YES;
if ("no".equals(codeString))
return NO;
throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "yes", "no");
}
public String toCode() {
switch (this) {
case YES: return "yes";
case NO: return "no";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case YES: return "http://hl7.org/fhir/action-precheck-behavior";
case NO: return "http://hl7.org/fhir/action-precheck-behavior";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case YES: return "An action with this behavior is one of the most frequent action that is, or should be, included by an end user, for the particular context in which the action occurs. The system displaying the action to the end user should consider \"pre-checking\" such an action as a convenience for the user.";
case NO: return "An action with this behavior is one of the less frequent actions included by the end user, for the particular context in which the action occurs. The system displaying the actions to the end user would typically not \"pre-check\" such an action.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case YES: return "Yes";
case NO: return "No";
case NULL: return null;
default: return "?";
}
}
}
public static class ActionPrecheckBehaviorEnumFactory implements EnumFactory {
public ActionPrecheckBehavior fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("yes".equals(codeString))
return ActionPrecheckBehavior.YES;
if ("no".equals(codeString))
return ActionPrecheckBehavior.NO;
throw new IllegalArgumentException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ActionPrecheckBehavior.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ActionPrecheckBehavior.NULL, code);
if ("yes".equals(codeString))
return new Enumeration(this, ActionPrecheckBehavior.YES, code);
if ("no".equals(codeString))
return new Enumeration(this, ActionPrecheckBehavior.NO, code);
throw new FHIRException("Unknown ActionPrecheckBehavior code '"+codeString+"'");
}
public String toCode(ActionPrecheckBehavior code) {
if (code == ActionPrecheckBehavior.NULL)
return null;
if (code == ActionPrecheckBehavior.YES)
return "yes";
if (code == ActionPrecheckBehavior.NO)
return "no";
return "?";
}
public String toSystem(ActionPrecheckBehavior code) {
return code.getSystem();
}
}
public enum ActionRelationshipType {
/**
* The action must be performed before the related action.
*/
BEFORE,
/**
* The action must be performed before the start of the related action.
*/
BEFORESTART,
/**
* The action must be performed before the end of the related action.
*/
BEFOREEND,
/**
* The action must be performed concurrent with the related action.
*/
CONCURRENT,
/**
* The action must be performed concurrent with the start of the related action.
*/
CONCURRENTWITHSTART,
/**
* The action must be performed concurrent with the end of the related action.
*/
CONCURRENTWITHEND,
/**
* The action must be performed after the related action.
*/
AFTER,
/**
* The action must be performed after the start of the related action.
*/
AFTERSTART,
/**
* The action must be performed after the end of the related action.
*/
AFTEREND,
/**
* added to help the parsers
*/
NULL;
public static ActionRelationshipType fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("before".equals(codeString))
return BEFORE;
if ("before-start".equals(codeString))
return BEFORESTART;
if ("before-end".equals(codeString))
return BEFOREEND;
if ("concurrent".equals(codeString))
return CONCURRENT;
if ("concurrent-with-start".equals(codeString))
return CONCURRENTWITHSTART;
if ("concurrent-with-end".equals(codeString))
return CONCURRENTWITHEND;
if ("after".equals(codeString))
return AFTER;
if ("after-start".equals(codeString))
return AFTERSTART;
if ("after-end".equals(codeString))
return AFTEREND;
throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "before", "before-start", "before-end", "concurrent", "concurrent-with-start", "concurrent-with-end", "after", "after-start", "after-end");
}
public String toCode() {
switch (this) {
case BEFORE: return "before";
case BEFORESTART: return "before-start";
case BEFOREEND: return "before-end";
case CONCURRENT: return "concurrent";
case CONCURRENTWITHSTART: return "concurrent-with-start";
case CONCURRENTWITHEND: return "concurrent-with-end";
case AFTER: return "after";
case AFTERSTART: return "after-start";
case AFTEREND: return "after-end";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case BEFORE: return "http://hl7.org/fhir/action-relationship-type";
case BEFORESTART: return "http://hl7.org/fhir/action-relationship-type";
case BEFOREEND: return "http://hl7.org/fhir/action-relationship-type";
case CONCURRENT: return "http://hl7.org/fhir/action-relationship-type";
case CONCURRENTWITHSTART: return "http://hl7.org/fhir/action-relationship-type";
case CONCURRENTWITHEND: return "http://hl7.org/fhir/action-relationship-type";
case AFTER: return "http://hl7.org/fhir/action-relationship-type";
case AFTERSTART: return "http://hl7.org/fhir/action-relationship-type";
case AFTEREND: return "http://hl7.org/fhir/action-relationship-type";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case BEFORE: return "The action must be performed before the related action.";
case BEFORESTART: return "The action must be performed before the start of the related action.";
case BEFOREEND: return "The action must be performed before the end of the related action.";
case CONCURRENT: return "The action must be performed concurrent with the related action.";
case CONCURRENTWITHSTART: return "The action must be performed concurrent with the start of the related action.";
case CONCURRENTWITHEND: return "The action must be performed concurrent with the end of the related action.";
case AFTER: return "The action must be performed after the related action.";
case AFTERSTART: return "The action must be performed after the start of the related action.";
case AFTEREND: return "The action must be performed after the end of the related action.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case BEFORE: return "Before";
case BEFORESTART: return "Before Start";
case BEFOREEND: return "Before End";
case CONCURRENT: return "Concurrent";
case CONCURRENTWITHSTART: return "Concurrent With Start";
case CONCURRENTWITHEND: return "Concurrent With End";
case AFTER: return "After";
case AFTERSTART: return "After Start";
case AFTEREND: return "After End";
case NULL: return null;
default: return "?";
}
}
}
public static class ActionRelationshipTypeEnumFactory implements EnumFactory {
public ActionRelationshipType fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("before".equals(codeString))
return ActionRelationshipType.BEFORE;
if ("before-start".equals(codeString))
return ActionRelationshipType.BEFORESTART;
if ("before-end".equals(codeString))
return ActionRelationshipType.BEFOREEND;
if ("concurrent".equals(codeString))
return ActionRelationshipType.CONCURRENT;
if ("concurrent-with-start".equals(codeString))
return ActionRelationshipType.CONCURRENTWITHSTART;
if ("concurrent-with-end".equals(codeString))
return ActionRelationshipType.CONCURRENTWITHEND;
if ("after".equals(codeString))
return ActionRelationshipType.AFTER;
if ("after-start".equals(codeString))
return ActionRelationshipType.AFTERSTART;
if ("after-end".equals(codeString))
return ActionRelationshipType.AFTEREND;
throw new IllegalArgumentException("Unknown ActionRelationshipType code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ActionRelationshipType.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ActionRelationshipType.NULL, code);
if ("before".equals(codeString))
return new Enumeration(this, ActionRelationshipType.BEFORE, code);
if ("before-start".equals(codeString))
return new Enumeration(this, ActionRelationshipType.BEFORESTART, code);
if ("before-end".equals(codeString))
return new Enumeration(this, ActionRelationshipType.BEFOREEND, code);
if ("concurrent".equals(codeString))
return new Enumeration(this, ActionRelationshipType.CONCURRENT, code);
if ("concurrent-with-start".equals(codeString))
return new Enumeration(this, ActionRelationshipType.CONCURRENTWITHSTART, code);
if ("concurrent-with-end".equals(codeString))
return new Enumeration(this, ActionRelationshipType.CONCURRENTWITHEND, code);
if ("after".equals(codeString))
return new Enumeration(this, ActionRelationshipType.AFTER, code);
if ("after-start".equals(codeString))
return new Enumeration(this, ActionRelationshipType.AFTERSTART, code);
if ("after-end".equals(codeString))
return new Enumeration(this, ActionRelationshipType.AFTEREND, code);
throw new FHIRException("Unknown ActionRelationshipType code '"+codeString+"'");
}
public String toCode(ActionRelationshipType code) {
if (code == ActionRelationshipType.NULL)
return null;
if (code == ActionRelationshipType.BEFORE)
return "before";
if (code == ActionRelationshipType.BEFORESTART)
return "before-start";
if (code == ActionRelationshipType.BEFOREEND)
return "before-end";
if (code == ActionRelationshipType.CONCURRENT)
return "concurrent";
if (code == ActionRelationshipType.CONCURRENTWITHSTART)
return "concurrent-with-start";
if (code == ActionRelationshipType.CONCURRENTWITHEND)
return "concurrent-with-end";
if (code == ActionRelationshipType.AFTER)
return "after";
if (code == ActionRelationshipType.AFTERSTART)
return "after-start";
if (code == ActionRelationshipType.AFTEREND)
return "after-end";
return "?";
}
public String toSystem(ActionRelationshipType code) {
return code.getSystem();
}
}
public enum ActionRequiredBehavior {
/**
* An action with this behavior must be included in the actions processed by the end user; the end user SHALL NOT choose not to include this action.
*/
MUST,
/**
* An action with this behavior may be included in the set of actions processed by the end user.
*/
COULD,
/**
* An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included.
*/
MUSTUNLESSDOCUMENTED,
/**
* added to help the parsers
*/
NULL;
public static ActionRequiredBehavior fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("must".equals(codeString))
return MUST;
if ("could".equals(codeString))
return COULD;
if ("must-unless-documented".equals(codeString))
return MUSTUNLESSDOCUMENTED;
throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "must", "could", "must-unless-documented");
}
public String toCode() {
switch (this) {
case MUST: return "must";
case COULD: return "could";
case MUSTUNLESSDOCUMENTED: return "must-unless-documented";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case MUST: return "http://hl7.org/fhir/action-required-behavior";
case COULD: return "http://hl7.org/fhir/action-required-behavior";
case MUSTUNLESSDOCUMENTED: return "http://hl7.org/fhir/action-required-behavior";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case MUST: return "An action with this behavior must be included in the actions processed by the end user; the end user SHALL NOT choose not to include this action.";
case COULD: return "An action with this behavior may be included in the set of actions processed by the end user.";
case MUSTUNLESSDOCUMENTED: return "An action with this behavior must be included in the set of actions processed by the end user, unless the end user provides documentation as to why the action was not included.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case MUST: return "Must";
case COULD: return "Could";
case MUSTUNLESSDOCUMENTED: return "Must Unless Documented";
case NULL: return null;
default: return "?";
}
}
}
public static class ActionRequiredBehaviorEnumFactory implements EnumFactory {
public ActionRequiredBehavior fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("must".equals(codeString))
return ActionRequiredBehavior.MUST;
if ("could".equals(codeString))
return ActionRequiredBehavior.COULD;
if ("must-unless-documented".equals(codeString))
return ActionRequiredBehavior.MUSTUNLESSDOCUMENTED;
throw new IllegalArgumentException("Unknown ActionRequiredBehavior code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ActionRequiredBehavior.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ActionRequiredBehavior.NULL, code);
if ("must".equals(codeString))
return new Enumeration(this, ActionRequiredBehavior.MUST, code);
if ("could".equals(codeString))
return new Enumeration(this, ActionRequiredBehavior.COULD, code);
if ("must-unless-documented".equals(codeString))
return new Enumeration(this, ActionRequiredBehavior.MUSTUNLESSDOCUMENTED, code);
throw new FHIRException("Unknown ActionRequiredBehavior code '"+codeString+"'");
}
public String toCode(ActionRequiredBehavior code) {
if (code == ActionRequiredBehavior.NULL)
return null;
if (code == ActionRequiredBehavior.MUST)
return "must";
if (code == ActionRequiredBehavior.COULD)
return "could";
if (code == ActionRequiredBehavior.MUSTUNLESSDOCUMENTED)
return "must-unless-documented";
return "?";
}
public String toSystem(ActionRequiredBehavior code) {
return code.getSystem();
}
}
public enum ActionSelectionBehavior {
/**
* Any number of the actions in the group may be chosen, from zero to all.
*/
ANY,
/**
* All the actions in the group must be selected as a single unit.
*/
ALL,
/**
* All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected.
*/
ALLORNONE,
/**
* The end user must choose one and only one of the selectable actions in the group. The user SHALL NOT choose none of the actions in the group.
*/
EXACTLYONE,
/**
* The end user may choose zero or at most one of the actions in the group.
*/
ATMOSTONE,
/**
* The end user must choose a minimum of one, and as many additional as desired.
*/
ONEORMORE,
/**
* added to help the parsers
*/
NULL;
public static ActionSelectionBehavior fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("any".equals(codeString))
return ANY;
if ("all".equals(codeString))
return ALL;
if ("all-or-none".equals(codeString))
return ALLORNONE;
if ("exactly-one".equals(codeString))
return EXACTLYONE;
if ("at-most-one".equals(codeString))
return ATMOSTONE;
if ("one-or-more".equals(codeString))
return ONEORMORE;
throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "any", "all", "all-or-none", "exactly-one", "at-most-one", "one-or-more");
}
public String toCode() {
switch (this) {
case ANY: return "any";
case ALL: return "all";
case ALLORNONE: return "all-or-none";
case EXACTLYONE: return "exactly-one";
case ATMOSTONE: return "at-most-one";
case ONEORMORE: return "one-or-more";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case ANY: return "http://hl7.org/fhir/action-selection-behavior";
case ALL: return "http://hl7.org/fhir/action-selection-behavior";
case ALLORNONE: return "http://hl7.org/fhir/action-selection-behavior";
case EXACTLYONE: return "http://hl7.org/fhir/action-selection-behavior";
case ATMOSTONE: return "http://hl7.org/fhir/action-selection-behavior";
case ONEORMORE: return "http://hl7.org/fhir/action-selection-behavior";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case ANY: return "Any number of the actions in the group may be chosen, from zero to all.";
case ALL: return "All the actions in the group must be selected as a single unit.";
case ALLORNONE: return "All the actions in the group are meant to be chosen as a single unit: either all must be selected by the end user, or none may be selected.";
case EXACTLYONE: return "The end user must choose one and only one of the selectable actions in the group. The user SHALL NOT choose none of the actions in the group.";
case ATMOSTONE: return "The end user may choose zero or at most one of the actions in the group.";
case ONEORMORE: return "The end user must choose a minimum of one, and as many additional as desired.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case ANY: return "Any";
case ALL: return "All";
case ALLORNONE: return "All Or None";
case EXACTLYONE: return "Exactly One";
case ATMOSTONE: return "At Most One";
case ONEORMORE: return "One Or More";
case NULL: return null;
default: return "?";
}
}
}
public static class ActionSelectionBehaviorEnumFactory implements EnumFactory {
public ActionSelectionBehavior fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("any".equals(codeString))
return ActionSelectionBehavior.ANY;
if ("all".equals(codeString))
return ActionSelectionBehavior.ALL;
if ("all-or-none".equals(codeString))
return ActionSelectionBehavior.ALLORNONE;
if ("exactly-one".equals(codeString))
return ActionSelectionBehavior.EXACTLYONE;
if ("at-most-one".equals(codeString))
return ActionSelectionBehavior.ATMOSTONE;
if ("one-or-more".equals(codeString))
return ActionSelectionBehavior.ONEORMORE;
throw new IllegalArgumentException("Unknown ActionSelectionBehavior code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ActionSelectionBehavior.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ActionSelectionBehavior.NULL, code);
if ("any".equals(codeString))
return new Enumeration(this, ActionSelectionBehavior.ANY, code);
if ("all".equals(codeString))
return new Enumeration(this, ActionSelectionBehavior.ALL, code);
if ("all-or-none".equals(codeString))
return new Enumeration(this, ActionSelectionBehavior.ALLORNONE, code);
if ("exactly-one".equals(codeString))
return new Enumeration(this, ActionSelectionBehavior.EXACTLYONE, code);
if ("at-most-one".equals(codeString))
return new Enumeration(this, ActionSelectionBehavior.ATMOSTONE, code);
if ("one-or-more".equals(codeString))
return new Enumeration(this, ActionSelectionBehavior.ONEORMORE, code);
throw new FHIRException("Unknown ActionSelectionBehavior code '"+codeString+"'");
}
public String toCode(ActionSelectionBehavior code) {
if (code == ActionSelectionBehavior.NULL)
return null;
if (code == ActionSelectionBehavior.ANY)
return "any";
if (code == ActionSelectionBehavior.ALL)
return "all";
if (code == ActionSelectionBehavior.ALLORNONE)
return "all-or-none";
if (code == ActionSelectionBehavior.EXACTLYONE)
return "exactly-one";
if (code == ActionSelectionBehavior.ATMOSTONE)
return "at-most-one";
if (code == ActionSelectionBehavior.ONEORMORE)
return "one-or-more";
return "?";
}
public String toSystem(ActionSelectionBehavior code) {
return code.getSystem();
}
}
public enum AdministrativeGender {
/**
* Male.
*/
MALE,
/**
* Female.
*/
FEMALE,
/**
* Other.
*/
OTHER,
/**
* Unknown.
*/
UNKNOWN,
/**
* added to help the parsers
*/
NULL;
public static AdministrativeGender fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("male".equals(codeString))
return MALE;
if ("female".equals(codeString))
return FEMALE;
if ("other".equals(codeString))
return OTHER;
if ("unknown".equals(codeString))
return UNKNOWN;
throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "male", "female", "other", "unknown");
}
public String toCode() {
switch (this) {
case MALE: return "male";
case FEMALE: return "female";
case OTHER: return "other";
case UNKNOWN: return "unknown";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case MALE: return "http://hl7.org/fhir/administrative-gender";
case FEMALE: return "http://hl7.org/fhir/administrative-gender";
case OTHER: return "http://hl7.org/fhir/administrative-gender";
case UNKNOWN: return "http://hl7.org/fhir/administrative-gender";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case MALE: return "Male.";
case FEMALE: return "Female.";
case OTHER: return "Other.";
case UNKNOWN: return "Unknown.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case MALE: return "Male";
case FEMALE: return "Female";
case OTHER: return "Other";
case UNKNOWN: return "Unknown";
case NULL: return null;
default: return "?";
}
}
}
public static class AdministrativeGenderEnumFactory implements EnumFactory {
public AdministrativeGender fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("male".equals(codeString))
return AdministrativeGender.MALE;
if ("female".equals(codeString))
return AdministrativeGender.FEMALE;
if ("other".equals(codeString))
return AdministrativeGender.OTHER;
if ("unknown".equals(codeString))
return AdministrativeGender.UNKNOWN;
throw new IllegalArgumentException("Unknown AdministrativeGender code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, AdministrativeGender.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, AdministrativeGender.NULL, code);
if ("male".equals(codeString))
return new Enumeration(this, AdministrativeGender.MALE, code);
if ("female".equals(codeString))
return new Enumeration(this, AdministrativeGender.FEMALE, code);
if ("other".equals(codeString))
return new Enumeration(this, AdministrativeGender.OTHER, code);
if ("unknown".equals(codeString))
return new Enumeration(this, AdministrativeGender.UNKNOWN, code);
throw new FHIRException("Unknown AdministrativeGender code '"+codeString+"'");
}
public String toCode(AdministrativeGender code) {
if (code == AdministrativeGender.NULL)
return null;
if (code == AdministrativeGender.MALE)
return "male";
if (code == AdministrativeGender.FEMALE)
return "female";
if (code == AdministrativeGender.OTHER)
return "other";
if (code == AdministrativeGender.UNKNOWN)
return "unknown";
return "?";
}
public String toSystem(AdministrativeGender code) {
return code.getSystem();
}
}
public enum AllLanguages {
/**
* added to help the parsers
*/
NULL;
public static AllLanguages fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
throw new FHIRException("Unknown AllLanguages code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString);
}
public String toCode() {
switch (this) {
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case NULL: return null;
default: return "?";
}
}
}
public static class AllLanguagesEnumFactory implements EnumFactory {
public AllLanguages fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
throw new IllegalArgumentException("Unknown AllLanguages code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, AllLanguages.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, AllLanguages.NULL, code);
throw new FHIRException("Unknown AllLanguages code '"+codeString+"'");
}
public String toCode(AllLanguages code) {
if (code == AllLanguages.NULL)
return null;
return "?";
}
public String toSystem(AllLanguages code) {
return code.getSystem();
}
}
public enum BindingStrength {
/**
* To be conformant, the concept in this element SHALL be from the specified value set.
*/
REQUIRED,
/**
* To be conformant, the concept in this element SHALL be from the specified value set if any of the codes within the value set can apply to the concept being communicated. If the value set does not cover the concept (based on human review), alternate codings (or, data type allowing, text) may be included instead.
*/
EXTENSIBLE,
/**
* Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant.
*/
PREFERRED,
/**
* Instances are not expected or even encouraged to draw from the specified value set. The value set merely provides examples of the types of concepts intended to be included.
*/
EXAMPLE,
/**
* added to help the parsers
*/
NULL;
public static BindingStrength fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("required".equals(codeString))
return REQUIRED;
if ("extensible".equals(codeString))
return EXTENSIBLE;
if ("preferred".equals(codeString))
return PREFERRED;
if ("example".equals(codeString))
return EXAMPLE;
throw new FHIRException("Unknown BindingStrength code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "required", "extensible", "preferred", "example");
}
public String toCode() {
switch (this) {
case REQUIRED: return "required";
case EXTENSIBLE: return "extensible";
case PREFERRED: return "preferred";
case EXAMPLE: return "example";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case REQUIRED: return "http://hl7.org/fhir/binding-strength";
case EXTENSIBLE: return "http://hl7.org/fhir/binding-strength";
case PREFERRED: return "http://hl7.org/fhir/binding-strength";
case EXAMPLE: return "http://hl7.org/fhir/binding-strength";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case REQUIRED: return "To be conformant, the concept in this element SHALL be from the specified value set.";
case EXTENSIBLE: return "To be conformant, the concept in this element SHALL be from the specified value set if any of the codes within the value set can apply to the concept being communicated. If the value set does not cover the concept (based on human review), alternate codings (or, data type allowing, text) may be included instead.";
case PREFERRED: return "Instances are encouraged to draw from the specified codes for interoperability purposes but are not required to do so to be considered conformant.";
case EXAMPLE: return "Instances are not expected or even encouraged to draw from the specified value set. The value set merely provides examples of the types of concepts intended to be included.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case REQUIRED: return "Required";
case EXTENSIBLE: return "Extensible";
case PREFERRED: return "Preferred";
case EXAMPLE: return "Example";
case NULL: return null;
default: return "?";
}
}
}
public static class BindingStrengthEnumFactory implements EnumFactory {
public BindingStrength fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("required".equals(codeString))
return BindingStrength.REQUIRED;
if ("extensible".equals(codeString))
return BindingStrength.EXTENSIBLE;
if ("preferred".equals(codeString))
return BindingStrength.PREFERRED;
if ("example".equals(codeString))
return BindingStrength.EXAMPLE;
throw new IllegalArgumentException("Unknown BindingStrength code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, BindingStrength.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, BindingStrength.NULL, code);
if ("required".equals(codeString))
return new Enumeration(this, BindingStrength.REQUIRED, code);
if ("extensible".equals(codeString))
return new Enumeration(this, BindingStrength.EXTENSIBLE, code);
if ("preferred".equals(codeString))
return new Enumeration(this, BindingStrength.PREFERRED, code);
if ("example".equals(codeString))
return new Enumeration(this, BindingStrength.EXAMPLE, code);
throw new FHIRException("Unknown BindingStrength code '"+codeString+"'");
}
public String toCode(BindingStrength code) {
if (code == BindingStrength.NULL)
return null;
if (code == BindingStrength.REQUIRED)
return "required";
if (code == BindingStrength.EXTENSIBLE)
return "extensible";
if (code == BindingStrength.PREFERRED)
return "preferred";
if (code == BindingStrength.EXAMPLE)
return "example";
return "?";
}
public String toSystem(BindingStrength code) {
return code.getSystem();
}
}
public enum CapabilityStatementKind {
/**
* The CapabilityStatement instance represents the present capabilities of a specific system instance. This is the kind returned by /metadata for a FHIR server end-point.
*/
INSTANCE,
/**
* The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation.
*/
CAPABILITY,
/**
* The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'.
*/
REQUIREMENTS,
/**
* added to help the parsers
*/
NULL;
public static CapabilityStatementKind fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("instance".equals(codeString))
return INSTANCE;
if ("capability".equals(codeString))
return CAPABILITY;
if ("requirements".equals(codeString))
return REQUIREMENTS;
throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "instance", "capability", "requirements");
}
public String toCode() {
switch (this) {
case INSTANCE: return "instance";
case CAPABILITY: return "capability";
case REQUIREMENTS: return "requirements";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case INSTANCE: return "http://hl7.org/fhir/capability-statement-kind";
case CAPABILITY: return "http://hl7.org/fhir/capability-statement-kind";
case REQUIREMENTS: return "http://hl7.org/fhir/capability-statement-kind";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case INSTANCE: return "The CapabilityStatement instance represents the present capabilities of a specific system instance. This is the kind returned by /metadata for a FHIR server end-point.";
case CAPABILITY: return "The CapabilityStatement instance represents the capabilities of a system or piece of software, independent of a particular installation.";
case REQUIREMENTS: return "The CapabilityStatement instance represents a set of requirements for other systems to meet; e.g. as part of an implementation guide or 'request for proposal'.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case INSTANCE: return "Instance";
case CAPABILITY: return "Capability";
case REQUIREMENTS: return "Requirements";
case NULL: return null;
default: return "?";
}
}
}
public static class CapabilityStatementKindEnumFactory implements EnumFactory {
public CapabilityStatementKind fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("instance".equals(codeString))
return CapabilityStatementKind.INSTANCE;
if ("capability".equals(codeString))
return CapabilityStatementKind.CAPABILITY;
if ("requirements".equals(codeString))
return CapabilityStatementKind.REQUIREMENTS;
throw new IllegalArgumentException("Unknown CapabilityStatementKind code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, CapabilityStatementKind.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, CapabilityStatementKind.NULL, code);
if ("instance".equals(codeString))
return new Enumeration(this, CapabilityStatementKind.INSTANCE, code);
if ("capability".equals(codeString))
return new Enumeration(this, CapabilityStatementKind.CAPABILITY, code);
if ("requirements".equals(codeString))
return new Enumeration(this, CapabilityStatementKind.REQUIREMENTS, code);
throw new FHIRException("Unknown CapabilityStatementKind code '"+codeString+"'");
}
public String toCode(CapabilityStatementKind code) {
if (code == CapabilityStatementKind.NULL)
return null;
if (code == CapabilityStatementKind.INSTANCE)
return "instance";
if (code == CapabilityStatementKind.CAPABILITY)
return "capability";
if (code == CapabilityStatementKind.REQUIREMENTS)
return "requirements";
return "?";
}
public String toSystem(CapabilityStatementKind code) {
return code.getSystem();
}
}
public enum ClaimProcessingCodes {
/**
* The Claim/Pre-authorization/Pre-determination has been received but processing has not begun.
*/
QUEUED,
/**
* The processing has completed without errors
*/
COMPLETE,
/**
* One or more errors have been detected in the Claim
*/
ERROR,
/**
* No errors have been detected in the Claim and some of the adjudication has been performed.
*/
PARTIAL,
/**
* added to help the parsers
*/
NULL;
public static ClaimProcessingCodes fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("queued".equals(codeString))
return QUEUED;
if ("complete".equals(codeString))
return COMPLETE;
if ("error".equals(codeString))
return ERROR;
if ("partial".equals(codeString))
return PARTIAL;
throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "queued", "complete", "error", "partial");
}
public String toCode() {
switch (this) {
case QUEUED: return "queued";
case COMPLETE: return "complete";
case ERROR: return "error";
case PARTIAL: return "partial";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case QUEUED: return "http://hl7.org/fhir/claim-outcome";
case COMPLETE: return "http://hl7.org/fhir/claim-outcome";
case ERROR: return "http://hl7.org/fhir/claim-outcome";
case PARTIAL: return "http://hl7.org/fhir/claim-outcome";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case QUEUED: return "The Claim/Pre-authorization/Pre-determination has been received but processing has not begun.";
case COMPLETE: return "The processing has completed without errors";
case ERROR: return "One or more errors have been detected in the Claim";
case PARTIAL: return "No errors have been detected in the Claim and some of the adjudication has been performed.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case QUEUED: return "Queued";
case COMPLETE: return "Processing Complete";
case ERROR: return "Error";
case PARTIAL: return "Partial Processing";
case NULL: return null;
default: return "?";
}
}
}
public static class ClaimProcessingCodesEnumFactory implements EnumFactory {
public ClaimProcessingCodes fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("queued".equals(codeString))
return ClaimProcessingCodes.QUEUED;
if ("complete".equals(codeString))
return ClaimProcessingCodes.COMPLETE;
if ("error".equals(codeString))
return ClaimProcessingCodes.ERROR;
if ("partial".equals(codeString))
return ClaimProcessingCodes.PARTIAL;
throw new IllegalArgumentException("Unknown ClaimProcessingCodes code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ClaimProcessingCodes.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ClaimProcessingCodes.NULL, code);
if ("queued".equals(codeString))
return new Enumeration(this, ClaimProcessingCodes.QUEUED, code);
if ("complete".equals(codeString))
return new Enumeration(this, ClaimProcessingCodes.COMPLETE, code);
if ("error".equals(codeString))
return new Enumeration(this, ClaimProcessingCodes.ERROR, code);
if ("partial".equals(codeString))
return new Enumeration(this, ClaimProcessingCodes.PARTIAL, code);
throw new FHIRException("Unknown ClaimProcessingCodes code '"+codeString+"'");
}
public String toCode(ClaimProcessingCodes code) {
if (code == ClaimProcessingCodes.NULL)
return null;
if (code == ClaimProcessingCodes.QUEUED)
return "queued";
if (code == ClaimProcessingCodes.COMPLETE)
return "complete";
if (code == ClaimProcessingCodes.ERROR)
return "error";
if (code == ClaimProcessingCodes.PARTIAL)
return "partial";
return "?";
}
public String toSystem(ClaimProcessingCodes code) {
return code.getSystem();
}
}
public enum CodeSystemContentMode {
/**
* None of the concepts defined by the code system are included in the code system resource.
*/
NOTPRESENT,
/**
* A subset of the valid externally defined concepts are included in the code system resource. There is no specific purpose or documented intent other than for illustrative purposes.
*/
EXAMPLE,
/**
* A subset of the code system concepts are included in the code system resource. This is a curated subset released for a specific purpose under the governance of the code system steward, and that the intent, bounds and consequences of the fragmentation are clearly defined in the fragment or the code system documentation. Fragments are also known as partitions.
*/
FRAGMENT,
/**
* All the concepts defined by the code system are included in the code system resource.
*/
COMPLETE,
/**
* The resource doesn't define any new concepts; it just provides additional designations and properties to another code system.
*/
SUPPLEMENT,
/**
* added to help the parsers
*/
NULL;
public static CodeSystemContentMode fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("not-present".equals(codeString))
return NOTPRESENT;
if ("example".equals(codeString))
return EXAMPLE;
if ("fragment".equals(codeString))
return FRAGMENT;
if ("complete".equals(codeString))
return COMPLETE;
if ("supplement".equals(codeString))
return SUPPLEMENT;
throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "not-present", "example", "fragment", "complete", "supplement");
}
public String toCode() {
switch (this) {
case NOTPRESENT: return "not-present";
case EXAMPLE: return "example";
case FRAGMENT: return "fragment";
case COMPLETE: return "complete";
case SUPPLEMENT: return "supplement";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case NOTPRESENT: return "http://hl7.org/fhir/codesystem-content-mode";
case EXAMPLE: return "http://hl7.org/fhir/codesystem-content-mode";
case FRAGMENT: return "http://hl7.org/fhir/codesystem-content-mode";
case COMPLETE: return "http://hl7.org/fhir/codesystem-content-mode";
case SUPPLEMENT: return "http://hl7.org/fhir/codesystem-content-mode";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case NOTPRESENT: return "None of the concepts defined by the code system are included in the code system resource.";
case EXAMPLE: return "A subset of the valid externally defined concepts are included in the code system resource. There is no specific purpose or documented intent other than for illustrative purposes.";
case FRAGMENT: return "A subset of the code system concepts are included in the code system resource. This is a curated subset released for a specific purpose under the governance of the code system steward, and that the intent, bounds and consequences of the fragmentation are clearly defined in the fragment or the code system documentation. Fragments are also known as partitions.";
case COMPLETE: return "All the concepts defined by the code system are included in the code system resource.";
case SUPPLEMENT: return "The resource doesn't define any new concepts; it just provides additional designations and properties to another code system.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case NOTPRESENT: return "Not Present";
case EXAMPLE: return "Example";
case FRAGMENT: return "Fragment";
case COMPLETE: return "Complete";
case SUPPLEMENT: return "Supplement";
case NULL: return null;
default: return "?";
}
}
}
public static class CodeSystemContentModeEnumFactory implements EnumFactory {
public CodeSystemContentMode fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("not-present".equals(codeString))
return CodeSystemContentMode.NOTPRESENT;
if ("example".equals(codeString))
return CodeSystemContentMode.EXAMPLE;
if ("fragment".equals(codeString))
return CodeSystemContentMode.FRAGMENT;
if ("complete".equals(codeString))
return CodeSystemContentMode.COMPLETE;
if ("supplement".equals(codeString))
return CodeSystemContentMode.SUPPLEMENT;
throw new IllegalArgumentException("Unknown CodeSystemContentMode code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, CodeSystemContentMode.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, CodeSystemContentMode.NULL, code);
if ("not-present".equals(codeString))
return new Enumeration(this, CodeSystemContentMode.NOTPRESENT, code);
if ("example".equals(codeString))
return new Enumeration(this, CodeSystemContentMode.EXAMPLE, code);
if ("fragment".equals(codeString))
return new Enumeration(this, CodeSystemContentMode.FRAGMENT, code);
if ("complete".equals(codeString))
return new Enumeration(this, CodeSystemContentMode.COMPLETE, code);
if ("supplement".equals(codeString))
return new Enumeration(this, CodeSystemContentMode.SUPPLEMENT, code);
throw new FHIRException("Unknown CodeSystemContentMode code '"+codeString+"'");
}
public String toCode(CodeSystemContentMode code) {
if (code == CodeSystemContentMode.NULL)
return null;
if (code == CodeSystemContentMode.NOTPRESENT)
return "not-present";
if (code == CodeSystemContentMode.EXAMPLE)
return "example";
if (code == CodeSystemContentMode.FRAGMENT)
return "fragment";
if (code == CodeSystemContentMode.COMPLETE)
return "complete";
if (code == CodeSystemContentMode.SUPPLEMENT)
return "supplement";
return "?";
}
public String toSystem(CodeSystemContentMode code) {
return code.getSystem();
}
}
public enum CommonLanguages {
/**
* null
*/
AR,
/**
* null
*/
BG,
/**
* null
*/
BGBG,
/**
* null
*/
BN,
/**
* null
*/
CS,
/**
* null
*/
CSCZ,
/**
* null
*/
BS,
/**
* null
*/
BSBA,
/**
* null
*/
DA,
/**
* null
*/
DADK,
/**
* null
*/
DE,
/**
* null
*/
DEAT,
/**
* null
*/
DECH,
/**
* null
*/
DEDE,
/**
* null
*/
EL,
/**
* null
*/
ELGR,
/**
* null
*/
EN,
/**
* null
*/
ENAU,
/**
* null
*/
ENCA,
/**
* null
*/
ENGB,
/**
* null
*/
ENIN,
/**
* null
*/
ENNZ,
/**
* null
*/
ENSG,
/**
* null
*/
ENUS,
/**
* null
*/
ES,
/**
* null
*/
ESAR,
/**
* null
*/
ESES,
/**
* null
*/
ESUY,
/**
* null
*/
ET,
/**
* null
*/
ETEE,
/**
* null
*/
FI,
/**
* null
*/
FR,
/**
* null
*/
FRBE,
/**
* null
*/
FRCH,
/**
* null
*/
FRFR,
/**
* null
*/
FIFI,
/**
* null
*/
FRCA,
/**
* null
*/
FY,
/**
* null
*/
FYNL,
/**
* null
*/
HI,
/**
* null
*/
HR,
/**
* null
*/
HRHR,
/**
* null
*/
IS,
/**
* null
*/
ISIS,
/**
* null
*/
IT,
/**
* null
*/
ITCH,
/**
* null
*/
ITIT,
/**
* null
*/
JA,
/**
* null
*/
KO,
/**
* null
*/
LT,
/**
* null
*/
LTLT,
/**
* null
*/
LV,
/**
* null
*/
LVLV,
/**
* null
*/
NL,
/**
* null
*/
NLBE,
/**
* null
*/
NLNL,
/**
* null
*/
NO,
/**
* null
*/
NONO,
/**
* null
*/
PA,
/**
* null
*/
PL,
/**
* null
*/
PLPL,
/**
* null
*/
PT,
/**
* null
*/
PTPT,
/**
* null
*/
PTBR,
/**
* null
*/
RO,
/**
* null
*/
RORO,
/**
* null
*/
RU,
/**
* null
*/
RURU,
/**
* null
*/
SK,
/**
* null
*/
SKSK,
/**
* null
*/
SL,
/**
* null
*/
SLSI,
/**
* null
*/
SR,
/**
* null
*/
SRRS,
/**
* null
*/
SV,
/**
* null
*/
SVSE,
/**
* null
*/
TE,
/**
* null
*/
ZH,
/**
* null
*/
ZHCN,
/**
* null
*/
ZHHK,
/**
* null
*/
ZHSG,
/**
* null
*/
ZHTW,
/**
* added to help the parsers
*/
NULL;
public static CommonLanguages fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("ar".equals(codeString))
return AR;
if ("bg".equals(codeString))
return BG;
if ("bg-BG".equals(codeString))
return BGBG;
if ("bn".equals(codeString))
return BN;
if ("cs".equals(codeString))
return CS;
if ("cs-CZ".equals(codeString))
return CSCZ;
if ("bs".equals(codeString))
return BS;
if ("bs-BA".equals(codeString))
return BSBA;
if ("da".equals(codeString))
return DA;
if ("da-DK".equals(codeString))
return DADK;
if ("de".equals(codeString))
return DE;
if ("de-AT".equals(codeString))
return DEAT;
if ("de-CH".equals(codeString))
return DECH;
if ("de-DE".equals(codeString))
return DEDE;
if ("el".equals(codeString))
return EL;
if ("el-GR".equals(codeString))
return ELGR;
if ("en".equals(codeString))
return EN;
if ("en-AU".equals(codeString))
return ENAU;
if ("en-CA".equals(codeString))
return ENCA;
if ("en-GB".equals(codeString))
return ENGB;
if ("en-IN".equals(codeString))
return ENIN;
if ("en-NZ".equals(codeString))
return ENNZ;
if ("en-SG".equals(codeString))
return ENSG;
if ("en-US".equals(codeString))
return ENUS;
if ("es".equals(codeString))
return ES;
if ("es-AR".equals(codeString))
return ESAR;
if ("es-ES".equals(codeString))
return ESES;
if ("es-UY".equals(codeString))
return ESUY;
if ("et".equals(codeString))
return ET;
if ("et-EE".equals(codeString))
return ETEE;
if ("fi".equals(codeString))
return FI;
if ("fr".equals(codeString))
return FR;
if ("fr-BE".equals(codeString))
return FRBE;
if ("fr-CH".equals(codeString))
return FRCH;
if ("fr-FR".equals(codeString))
return FRFR;
if ("fi-FI".equals(codeString))
return FIFI;
if ("fr-CA".equals(codeString))
return FRCA;
if ("fy".equals(codeString))
return FY;
if ("fy-NL".equals(codeString))
return FYNL;
if ("hi".equals(codeString))
return HI;
if ("hr".equals(codeString))
return HR;
if ("hr-HR".equals(codeString))
return HRHR;
if ("is".equals(codeString))
return IS;
if ("is-IS".equals(codeString))
return ISIS;
if ("it".equals(codeString))
return IT;
if ("it-CH".equals(codeString))
return ITCH;
if ("it-IT".equals(codeString))
return ITIT;
if ("ja".equals(codeString))
return JA;
if ("ko".equals(codeString))
return KO;
if ("lt".equals(codeString))
return LT;
if ("lt-LT".equals(codeString))
return LTLT;
if ("lv".equals(codeString))
return LV;
if ("lv-LV".equals(codeString))
return LVLV;
if ("nl".equals(codeString))
return NL;
if ("nl-BE".equals(codeString))
return NLBE;
if ("nl-NL".equals(codeString))
return NLNL;
if ("no".equals(codeString))
return NO;
if ("no-NO".equals(codeString))
return NONO;
if ("pa".equals(codeString))
return PA;
if ("pl".equals(codeString))
return PL;
if ("pl-PL".equals(codeString))
return PLPL;
if ("pt".equals(codeString))
return PT;
if ("pt-PT".equals(codeString))
return PTPT;
if ("pt-BR".equals(codeString))
return PTBR;
if ("ro".equals(codeString))
return RO;
if ("ro-RO".equals(codeString))
return RORO;
if ("ru".equals(codeString))
return RU;
if ("ru-RU".equals(codeString))
return RURU;
if ("sk".equals(codeString))
return SK;
if ("sk-SK".equals(codeString))
return SKSK;
if ("sl".equals(codeString))
return SL;
if ("sl-SI".equals(codeString))
return SLSI;
if ("sr".equals(codeString))
return SR;
if ("sr-RS".equals(codeString))
return SRRS;
if ("sv".equals(codeString))
return SV;
if ("sv-SE".equals(codeString))
return SVSE;
if ("te".equals(codeString))
return TE;
if ("zh".equals(codeString))
return ZH;
if ("zh-CN".equals(codeString))
return ZHCN;
if ("zh-HK".equals(codeString))
return ZHHK;
if ("zh-SG".equals(codeString))
return ZHSG;
if ("zh-TW".equals(codeString))
return ZHTW;
throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "ar", "bg", "bg-BG", "bn", "cs", "cs-CZ", "bs", "bs-BA", "da", "da-DK", "de", "de-AT", "de-CH", "de-DE", "el", "el-GR", "en", "en-AU", "en-CA", "en-GB", "en-IN", "en-NZ", "en-SG", "en-US", "es", "es-AR", "es-ES", "es-UY", "et", "et-EE", "fi", "fr", "fr-BE", "fr-CH", "fr-FR", "fi-FI", "fr-CA", "fy", "fy-NL", "hi", "hr", "hr-HR", "is", "is-IS", "it", "it-CH", "it-IT", "ja", "ko", "lt", "lt-LT", "lv", "lv-LV", "nl", "nl-BE", "nl-NL", "no", "no-NO", "pa", "pl", "pl-PL", "pt", "pt-PT", "pt-BR", "ro", "ro-RO", "ru", "ru-RU", "sk", "sk-SK", "sl", "sl-SI", "sr", "sr-RS", "sv", "sv-SE", "te", "zh", "zh-CN", "zh-HK", "zh-SG", "zh-TW");
}
public String toCode() {
switch (this) {
case AR: return "ar";
case BG: return "bg";
case BGBG: return "bg-BG";
case BN: return "bn";
case CS: return "cs";
case CSCZ: return "cs-CZ";
case BS: return "bs";
case BSBA: return "bs-BA";
case DA: return "da";
case DADK: return "da-DK";
case DE: return "de";
case DEAT: return "de-AT";
case DECH: return "de-CH";
case DEDE: return "de-DE";
case EL: return "el";
case ELGR: return "el-GR";
case EN: return "en";
case ENAU: return "en-AU";
case ENCA: return "en-CA";
case ENGB: return "en-GB";
case ENIN: return "en-IN";
case ENNZ: return "en-NZ";
case ENSG: return "en-SG";
case ENUS: return "en-US";
case ES: return "es";
case ESAR: return "es-AR";
case ESES: return "es-ES";
case ESUY: return "es-UY";
case ET: return "et";
case ETEE: return "et-EE";
case FI: return "fi";
case FR: return "fr";
case FRBE: return "fr-BE";
case FRCH: return "fr-CH";
case FRFR: return "fr-FR";
case FIFI: return "fi-FI";
case FRCA: return "fr-CA";
case FY: return "fy";
case FYNL: return "fy-NL";
case HI: return "hi";
case HR: return "hr";
case HRHR: return "hr-HR";
case IS: return "is";
case ISIS: return "is-IS";
case IT: return "it";
case ITCH: return "it-CH";
case ITIT: return "it-IT";
case JA: return "ja";
case KO: return "ko";
case LT: return "lt";
case LTLT: return "lt-LT";
case LV: return "lv";
case LVLV: return "lv-LV";
case NL: return "nl";
case NLBE: return "nl-BE";
case NLNL: return "nl-NL";
case NO: return "no";
case NONO: return "no-NO";
case PA: return "pa";
case PL: return "pl";
case PLPL: return "pl-PL";
case PT: return "pt";
case PTPT: return "pt-PT";
case PTBR: return "pt-BR";
case RO: return "ro";
case RORO: return "ro-RO";
case RU: return "ru";
case RURU: return "ru-RU";
case SK: return "sk";
case SKSK: return "sk-SK";
case SL: return "sl";
case SLSI: return "sl-SI";
case SR: return "sr";
case SRRS: return "sr-RS";
case SV: return "sv";
case SVSE: return "sv-SE";
case TE: return "te";
case ZH: return "zh";
case ZHCN: return "zh-CN";
case ZHHK: return "zh-HK";
case ZHSG: return "zh-SG";
case ZHTW: return "zh-TW";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case AR: return "urn:ietf:bcp:47";
case BG: return "urn:ietf:bcp:47";
case BGBG: return "urn:ietf:bcp:47";
case BN: return "urn:ietf:bcp:47";
case CS: return "urn:ietf:bcp:47";
case CSCZ: return "urn:ietf:bcp:47";
case BS: return "urn:ietf:bcp:47";
case BSBA: return "urn:ietf:bcp:47";
case DA: return "urn:ietf:bcp:47";
case DADK: return "urn:ietf:bcp:47";
case DE: return "urn:ietf:bcp:47";
case DEAT: return "urn:ietf:bcp:47";
case DECH: return "urn:ietf:bcp:47";
case DEDE: return "urn:ietf:bcp:47";
case EL: return "urn:ietf:bcp:47";
case ELGR: return "urn:ietf:bcp:47";
case EN: return "urn:ietf:bcp:47";
case ENAU: return "urn:ietf:bcp:47";
case ENCA: return "urn:ietf:bcp:47";
case ENGB: return "urn:ietf:bcp:47";
case ENIN: return "urn:ietf:bcp:47";
case ENNZ: return "urn:ietf:bcp:47";
case ENSG: return "urn:ietf:bcp:47";
case ENUS: return "urn:ietf:bcp:47";
case ES: return "urn:ietf:bcp:47";
case ESAR: return "urn:ietf:bcp:47";
case ESES: return "urn:ietf:bcp:47";
case ESUY: return "urn:ietf:bcp:47";
case ET: return "urn:ietf:bcp:47";
case ETEE: return "urn:ietf:bcp:47";
case FI: return "urn:ietf:bcp:47";
case FR: return "urn:ietf:bcp:47";
case FRBE: return "urn:ietf:bcp:47";
case FRCH: return "urn:ietf:bcp:47";
case FRFR: return "urn:ietf:bcp:47";
case FIFI: return "urn:ietf:bcp:47";
case FRCA: return "urn:ietf:bcp:47";
case FY: return "urn:ietf:bcp:47";
case FYNL: return "urn:ietf:bcp:47";
case HI: return "urn:ietf:bcp:47";
case HR: return "urn:ietf:bcp:47";
case HRHR: return "urn:ietf:bcp:47";
case IS: return "urn:ietf:bcp:47";
case ISIS: return "urn:ietf:bcp:47";
case IT: return "urn:ietf:bcp:47";
case ITCH: return "urn:ietf:bcp:47";
case ITIT: return "urn:ietf:bcp:47";
case JA: return "urn:ietf:bcp:47";
case KO: return "urn:ietf:bcp:47";
case LT: return "urn:ietf:bcp:47";
case LTLT: return "urn:ietf:bcp:47";
case LV: return "urn:ietf:bcp:47";
case LVLV: return "urn:ietf:bcp:47";
case NL: return "urn:ietf:bcp:47";
case NLBE: return "urn:ietf:bcp:47";
case NLNL: return "urn:ietf:bcp:47";
case NO: return "urn:ietf:bcp:47";
case NONO: return "urn:ietf:bcp:47";
case PA: return "urn:ietf:bcp:47";
case PL: return "urn:ietf:bcp:47";
case PLPL: return "urn:ietf:bcp:47";
case PT: return "urn:ietf:bcp:47";
case PTPT: return "urn:ietf:bcp:47";
case PTBR: return "urn:ietf:bcp:47";
case RO: return "urn:ietf:bcp:47";
case RORO: return "urn:ietf:bcp:47";
case RU: return "urn:ietf:bcp:47";
case RURU: return "urn:ietf:bcp:47";
case SK: return "urn:ietf:bcp:47";
case SKSK: return "urn:ietf:bcp:47";
case SL: return "urn:ietf:bcp:47";
case SLSI: return "urn:ietf:bcp:47";
case SR: return "urn:ietf:bcp:47";
case SRRS: return "urn:ietf:bcp:47";
case SV: return "urn:ietf:bcp:47";
case SVSE: return "urn:ietf:bcp:47";
case TE: return "urn:ietf:bcp:47";
case ZH: return "urn:ietf:bcp:47";
case ZHCN: return "urn:ietf:bcp:47";
case ZHHK: return "urn:ietf:bcp:47";
case ZHSG: return "urn:ietf:bcp:47";
case ZHTW: return "urn:ietf:bcp:47";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case AR: return "";
case BG: return "";
case BGBG: return "";
case BN: return "";
case CS: return "";
case CSCZ: return "";
case BS: return "";
case BSBA: return "";
case DA: return "";
case DADK: return "";
case DE: return "";
case DEAT: return "";
case DECH: return "";
case DEDE: return "";
case EL: return "";
case ELGR: return "";
case EN: return "";
case ENAU: return "";
case ENCA: return "";
case ENGB: return "";
case ENIN: return "";
case ENNZ: return "";
case ENSG: return "";
case ENUS: return "";
case ES: return "";
case ESAR: return "";
case ESES: return "";
case ESUY: return "";
case ET: return "";
case ETEE: return "";
case FI: return "";
case FR: return "";
case FRBE: return "";
case FRCH: return "";
case FRFR: return "";
case FIFI: return "";
case FRCA: return "";
case FY: return "";
case FYNL: return "";
case HI: return "";
case HR: return "";
case HRHR: return "";
case IS: return "";
case ISIS: return "";
case IT: return "";
case ITCH: return "";
case ITIT: return "";
case JA: return "";
case KO: return "";
case LT: return "";
case LTLT: return "";
case LV: return "";
case LVLV: return "";
case NL: return "";
case NLBE: return "";
case NLNL: return "";
case NO: return "";
case NONO: return "";
case PA: return "";
case PL: return "";
case PLPL: return "";
case PT: return "";
case PTPT: return "";
case PTBR: return "";
case RO: return "";
case RORO: return "";
case RU: return "";
case RURU: return "";
case SK: return "";
case SKSK: return "";
case SL: return "";
case SLSI: return "";
case SR: return "";
case SRRS: return "";
case SV: return "";
case SVSE: return "";
case TE: return "";
case ZH: return "";
case ZHCN: return "";
case ZHHK: return "";
case ZHSG: return "";
case ZHTW: return "";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case AR: return "Arabisk";
case BG: return "Bulgarian";
case BGBG: return "Bulgarian (Bulgaria)";
case BN: return "Bengali";
case CS: return "Czech";
case CSCZ: return "Czech (Czechia)";
case BS: return "Bosnian";
case BSBA: return "Bosnian (Bosnia and Herzegovina))";
case DA: return "Danish";
case DADK: return "Danish (Denmark)";
case DE: return "German";
case DEAT: return "German (Austria)";
case DECH: return "German (Switzerland)";
case DEDE: return "German (Germany)";
case EL: return "Greek";
case ELGR: return "Greek (Greece)";
case EN: return "English";
case ENAU: return "English (Australia)";
case ENCA: return "English (Canada)";
case ENGB: return "English (Great Britain)";
case ENIN: return "English (India)";
case ENNZ: return "English (New Zealand)";
case ENSG: return "English (Singapore)";
case ENUS: return "English (United States)";
case ES: return "Spanish";
case ESAR: return "Spanish (Argentina)";
case ESES: return "Spanish (Spain)";
case ESUY: return "Spanish (Uruguay)";
case ET: return "Estonian";
case ETEE: return "Estonian (Estonia)";
case FI: return "Finnish";
case FR: return "French";
case FRBE: return "French (Belgium)";
case FRCH: return "French (Switzerland)";
case FRFR: return "French (France)";
case FIFI: return "Finnish (Finland)";
case FRCA: return "French (Canada)";
case FY: return "Frisian";
case FYNL: return "Frisian (Netherlands)";
case HI: return "Hindi";
case HR: return "Croatian";
case HRHR: return "Croatian (Croatia)";
case IS: return "Icelandic";
case ISIS: return "Icelandic (Iceland)";
case IT: return "Italian";
case ITCH: return "Italian (Switzerland)";
case ITIT: return "Italian (Italy)";
case JA: return "Japanese";
case KO: return "Korean";
case LT: return "Lithuanian";
case LTLT: return "Lithuanian (Lithuania)";
case LV: return "Latvian";
case LVLV: return "Latvian (Latvia)";
case NL: return "Dutch";
case NLBE: return "Dutch (Belgium)";
case NLNL: return "Dutch (Netherlands)";
case NO: return "Norwegian";
case NONO: return "Norwegian (Norway)";
case PA: return "Punjabi";
case PL: return "Polskie";
case PLPL: return "Polish (Poland)";
case PT: return "Portuguese";
case PTPT: return "Portuguese (Portugal)";
case PTBR: return "Portuguese (Brazil)";
case RO: return "Romanian";
case RORO: return "Romanian (Romania)";
case RU: return "Russian";
case RURU: return "Russian (Russia)";
case SK: return "Slovakian";
case SKSK: return "Slovakian (Slovakia)";
case SL: return "Slovenian";
case SLSI: return "Slovenian (Slovenia)";
case SR: return "Serbian";
case SRRS: return "Serbian (Serbia)";
case SV: return "Swedish";
case SVSE: return "Swedish (Sweden)";
case TE: return "Telugu";
case ZH: return "Chinese";
case ZHCN: return "Chinese (China)";
case ZHHK: return "Chinese (Hong Kong)";
case ZHSG: return "Chinese (Singapore)";
case ZHTW: return "Chinese (Taiwan)";
case NULL: return null;
default: return "?";
}
}
}
public static class CommonLanguagesEnumFactory implements EnumFactory {
public CommonLanguages fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("ar".equals(codeString))
return CommonLanguages.AR;
if ("bg".equals(codeString))
return CommonLanguages.BG;
if ("bg-BG".equals(codeString))
return CommonLanguages.BGBG;
if ("bn".equals(codeString))
return CommonLanguages.BN;
if ("cs".equals(codeString))
return CommonLanguages.CS;
if ("cs-CZ".equals(codeString))
return CommonLanguages.CSCZ;
if ("bs".equals(codeString))
return CommonLanguages.BS;
if ("bs-BA".equals(codeString))
return CommonLanguages.BSBA;
if ("da".equals(codeString))
return CommonLanguages.DA;
if ("da-DK".equals(codeString))
return CommonLanguages.DADK;
if ("de".equals(codeString))
return CommonLanguages.DE;
if ("de-AT".equals(codeString))
return CommonLanguages.DEAT;
if ("de-CH".equals(codeString))
return CommonLanguages.DECH;
if ("de-DE".equals(codeString))
return CommonLanguages.DEDE;
if ("el".equals(codeString))
return CommonLanguages.EL;
if ("el-GR".equals(codeString))
return CommonLanguages.ELGR;
if ("en".equals(codeString))
return CommonLanguages.EN;
if ("en-AU".equals(codeString))
return CommonLanguages.ENAU;
if ("en-CA".equals(codeString))
return CommonLanguages.ENCA;
if ("en-GB".equals(codeString))
return CommonLanguages.ENGB;
if ("en-IN".equals(codeString))
return CommonLanguages.ENIN;
if ("en-NZ".equals(codeString))
return CommonLanguages.ENNZ;
if ("en-SG".equals(codeString))
return CommonLanguages.ENSG;
if ("en-US".equals(codeString))
return CommonLanguages.ENUS;
if ("es".equals(codeString))
return CommonLanguages.ES;
if ("es-AR".equals(codeString))
return CommonLanguages.ESAR;
if ("es-ES".equals(codeString))
return CommonLanguages.ESES;
if ("es-UY".equals(codeString))
return CommonLanguages.ESUY;
if ("et".equals(codeString))
return CommonLanguages.ET;
if ("et-EE".equals(codeString))
return CommonLanguages.ETEE;
if ("fi".equals(codeString))
return CommonLanguages.FI;
if ("fr".equals(codeString))
return CommonLanguages.FR;
if ("fr-BE".equals(codeString))
return CommonLanguages.FRBE;
if ("fr-CH".equals(codeString))
return CommonLanguages.FRCH;
if ("fr-FR".equals(codeString))
return CommonLanguages.FRFR;
if ("fi-FI".equals(codeString))
return CommonLanguages.FIFI;
if ("fr-CA".equals(codeString))
return CommonLanguages.FRCA;
if ("fy".equals(codeString))
return CommonLanguages.FY;
if ("fy-NL".equals(codeString))
return CommonLanguages.FYNL;
if ("hi".equals(codeString))
return CommonLanguages.HI;
if ("hr".equals(codeString))
return CommonLanguages.HR;
if ("hr-HR".equals(codeString))
return CommonLanguages.HRHR;
if ("is".equals(codeString))
return CommonLanguages.IS;
if ("is-IS".equals(codeString))
return CommonLanguages.ISIS;
if ("it".equals(codeString))
return CommonLanguages.IT;
if ("it-CH".equals(codeString))
return CommonLanguages.ITCH;
if ("it-IT".equals(codeString))
return CommonLanguages.ITIT;
if ("ja".equals(codeString))
return CommonLanguages.JA;
if ("ko".equals(codeString))
return CommonLanguages.KO;
if ("lt".equals(codeString))
return CommonLanguages.LT;
if ("lt-LT".equals(codeString))
return CommonLanguages.LTLT;
if ("lv".equals(codeString))
return CommonLanguages.LV;
if ("lv-LV".equals(codeString))
return CommonLanguages.LVLV;
if ("nl".equals(codeString))
return CommonLanguages.NL;
if ("nl-BE".equals(codeString))
return CommonLanguages.NLBE;
if ("nl-NL".equals(codeString))
return CommonLanguages.NLNL;
if ("no".equals(codeString))
return CommonLanguages.NO;
if ("no-NO".equals(codeString))
return CommonLanguages.NONO;
if ("pa".equals(codeString))
return CommonLanguages.PA;
if ("pl".equals(codeString))
return CommonLanguages.PL;
if ("pl-PL".equals(codeString))
return CommonLanguages.PLPL;
if ("pt".equals(codeString))
return CommonLanguages.PT;
if ("pt-PT".equals(codeString))
return CommonLanguages.PTPT;
if ("pt-BR".equals(codeString))
return CommonLanguages.PTBR;
if ("ro".equals(codeString))
return CommonLanguages.RO;
if ("ro-RO".equals(codeString))
return CommonLanguages.RORO;
if ("ru".equals(codeString))
return CommonLanguages.RU;
if ("ru-RU".equals(codeString))
return CommonLanguages.RURU;
if ("sk".equals(codeString))
return CommonLanguages.SK;
if ("sk-SK".equals(codeString))
return CommonLanguages.SKSK;
if ("sl".equals(codeString))
return CommonLanguages.SL;
if ("sl-SI".equals(codeString))
return CommonLanguages.SLSI;
if ("sr".equals(codeString))
return CommonLanguages.SR;
if ("sr-RS".equals(codeString))
return CommonLanguages.SRRS;
if ("sv".equals(codeString))
return CommonLanguages.SV;
if ("sv-SE".equals(codeString))
return CommonLanguages.SVSE;
if ("te".equals(codeString))
return CommonLanguages.TE;
if ("zh".equals(codeString))
return CommonLanguages.ZH;
if ("zh-CN".equals(codeString))
return CommonLanguages.ZHCN;
if ("zh-HK".equals(codeString))
return CommonLanguages.ZHHK;
if ("zh-SG".equals(codeString))
return CommonLanguages.ZHSG;
if ("zh-TW".equals(codeString))
return CommonLanguages.ZHTW;
throw new IllegalArgumentException("Unknown CommonLanguages code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, CommonLanguages.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, CommonLanguages.NULL, code);
if ("ar".equals(codeString))
return new Enumeration(this, CommonLanguages.AR, code);
if ("bg".equals(codeString))
return new Enumeration(this, CommonLanguages.BG, code);
if ("bg-BG".equals(codeString))
return new Enumeration(this, CommonLanguages.BGBG, code);
if ("bn".equals(codeString))
return new Enumeration(this, CommonLanguages.BN, code);
if ("cs".equals(codeString))
return new Enumeration(this, CommonLanguages.CS, code);
if ("cs-CZ".equals(codeString))
return new Enumeration(this, CommonLanguages.CSCZ, code);
if ("bs".equals(codeString))
return new Enumeration(this, CommonLanguages.BS, code);
if ("bs-BA".equals(codeString))
return new Enumeration(this, CommonLanguages.BSBA, code);
if ("da".equals(codeString))
return new Enumeration(this, CommonLanguages.DA, code);
if ("da-DK".equals(codeString))
return new Enumeration(this, CommonLanguages.DADK, code);
if ("de".equals(codeString))
return new Enumeration(this, CommonLanguages.DE, code);
if ("de-AT".equals(codeString))
return new Enumeration(this, CommonLanguages.DEAT, code);
if ("de-CH".equals(codeString))
return new Enumeration(this, CommonLanguages.DECH, code);
if ("de-DE".equals(codeString))
return new Enumeration(this, CommonLanguages.DEDE, code);
if ("el".equals(codeString))
return new Enumeration(this, CommonLanguages.EL, code);
if ("el-GR".equals(codeString))
return new Enumeration(this, CommonLanguages.ELGR, code);
if ("en".equals(codeString))
return new Enumeration(this, CommonLanguages.EN, code);
if ("en-AU".equals(codeString))
return new Enumeration(this, CommonLanguages.ENAU, code);
if ("en-CA".equals(codeString))
return new Enumeration(this, CommonLanguages.ENCA, code);
if ("en-GB".equals(codeString))
return new Enumeration(this, CommonLanguages.ENGB, code);
if ("en-IN".equals(codeString))
return new Enumeration(this, CommonLanguages.ENIN, code);
if ("en-NZ".equals(codeString))
return new Enumeration(this, CommonLanguages.ENNZ, code);
if ("en-SG".equals(codeString))
return new Enumeration(this, CommonLanguages.ENSG, code);
if ("en-US".equals(codeString))
return new Enumeration(this, CommonLanguages.ENUS, code);
if ("es".equals(codeString))
return new Enumeration(this, CommonLanguages.ES, code);
if ("es-AR".equals(codeString))
return new Enumeration(this, CommonLanguages.ESAR, code);
if ("es-ES".equals(codeString))
return new Enumeration(this, CommonLanguages.ESES, code);
if ("es-UY".equals(codeString))
return new Enumeration(this, CommonLanguages.ESUY, code);
if ("et".equals(codeString))
return new Enumeration(this, CommonLanguages.ET, code);
if ("et-EE".equals(codeString))
return new Enumeration(this, CommonLanguages.ETEE, code);
if ("fi".equals(codeString))
return new Enumeration(this, CommonLanguages.FI, code);
if ("fr".equals(codeString))
return new Enumeration(this, CommonLanguages.FR, code);
if ("fr-BE".equals(codeString))
return new Enumeration(this, CommonLanguages.FRBE, code);
if ("fr-CH".equals(codeString))
return new Enumeration(this, CommonLanguages.FRCH, code);
if ("fr-FR".equals(codeString))
return new Enumeration(this, CommonLanguages.FRFR, code);
if ("fi-FI".equals(codeString))
return new Enumeration(this, CommonLanguages.FIFI, code);
if ("fr-CA".equals(codeString))
return new Enumeration(this, CommonLanguages.FRCA, code);
if ("fy".equals(codeString))
return new Enumeration(this, CommonLanguages.FY, code);
if ("fy-NL".equals(codeString))
return new Enumeration(this, CommonLanguages.FYNL, code);
if ("hi".equals(codeString))
return new Enumeration(this, CommonLanguages.HI, code);
if ("hr".equals(codeString))
return new Enumeration(this, CommonLanguages.HR, code);
if ("hr-HR".equals(codeString))
return new Enumeration(this, CommonLanguages.HRHR, code);
if ("is".equals(codeString))
return new Enumeration(this, CommonLanguages.IS, code);
if ("is-IS".equals(codeString))
return new Enumeration(this, CommonLanguages.ISIS, code);
if ("it".equals(codeString))
return new Enumeration(this, CommonLanguages.IT, code);
if ("it-CH".equals(codeString))
return new Enumeration(this, CommonLanguages.ITCH, code);
if ("it-IT".equals(codeString))
return new Enumeration(this, CommonLanguages.ITIT, code);
if ("ja".equals(codeString))
return new Enumeration(this, CommonLanguages.JA, code);
if ("ko".equals(codeString))
return new Enumeration(this, CommonLanguages.KO, code);
if ("lt".equals(codeString))
return new Enumeration(this, CommonLanguages.LT, code);
if ("lt-LT".equals(codeString))
return new Enumeration(this, CommonLanguages.LTLT, code);
if ("lv".equals(codeString))
return new Enumeration(this, CommonLanguages.LV, code);
if ("lv-LV".equals(codeString))
return new Enumeration(this, CommonLanguages.LVLV, code);
if ("nl".equals(codeString))
return new Enumeration(this, CommonLanguages.NL, code);
if ("nl-BE".equals(codeString))
return new Enumeration(this, CommonLanguages.NLBE, code);
if ("nl-NL".equals(codeString))
return new Enumeration(this, CommonLanguages.NLNL, code);
if ("no".equals(codeString))
return new Enumeration(this, CommonLanguages.NO, code);
if ("no-NO".equals(codeString))
return new Enumeration(this, CommonLanguages.NONO, code);
if ("pa".equals(codeString))
return new Enumeration(this, CommonLanguages.PA, code);
if ("pl".equals(codeString))
return new Enumeration(this, CommonLanguages.PL, code);
if ("pl-PL".equals(codeString))
return new Enumeration(this, CommonLanguages.PLPL, code);
if ("pt".equals(codeString))
return new Enumeration(this, CommonLanguages.PT, code);
if ("pt-PT".equals(codeString))
return new Enumeration(this, CommonLanguages.PTPT, code);
if ("pt-BR".equals(codeString))
return new Enumeration(this, CommonLanguages.PTBR, code);
if ("ro".equals(codeString))
return new Enumeration(this, CommonLanguages.RO, code);
if ("ro-RO".equals(codeString))
return new Enumeration(this, CommonLanguages.RORO, code);
if ("ru".equals(codeString))
return new Enumeration(this, CommonLanguages.RU, code);
if ("ru-RU".equals(codeString))
return new Enumeration(this, CommonLanguages.RURU, code);
if ("sk".equals(codeString))
return new Enumeration(this, CommonLanguages.SK, code);
if ("sk-SK".equals(codeString))
return new Enumeration(this, CommonLanguages.SKSK, code);
if ("sl".equals(codeString))
return new Enumeration(this, CommonLanguages.SL, code);
if ("sl-SI".equals(codeString))
return new Enumeration(this, CommonLanguages.SLSI, code);
if ("sr".equals(codeString))
return new Enumeration(this, CommonLanguages.SR, code);
if ("sr-RS".equals(codeString))
return new Enumeration(this, CommonLanguages.SRRS, code);
if ("sv".equals(codeString))
return new Enumeration(this, CommonLanguages.SV, code);
if ("sv-SE".equals(codeString))
return new Enumeration(this, CommonLanguages.SVSE, code);
if ("te".equals(codeString))
return new Enumeration(this, CommonLanguages.TE, code);
if ("zh".equals(codeString))
return new Enumeration(this, CommonLanguages.ZH, code);
if ("zh-CN".equals(codeString))
return new Enumeration(this, CommonLanguages.ZHCN, code);
if ("zh-HK".equals(codeString))
return new Enumeration(this, CommonLanguages.ZHHK, code);
if ("zh-SG".equals(codeString))
return new Enumeration(this, CommonLanguages.ZHSG, code);
if ("zh-TW".equals(codeString))
return new Enumeration(this, CommonLanguages.ZHTW, code);
throw new FHIRException("Unknown CommonLanguages code '"+codeString+"'");
}
public String toCode(CommonLanguages code) {
if (code == CommonLanguages.NULL)
return null;
if (code == CommonLanguages.AR)
return "ar";
if (code == CommonLanguages.BG)
return "bg";
if (code == CommonLanguages.BGBG)
return "bg-BG";
if (code == CommonLanguages.BN)
return "bn";
if (code == CommonLanguages.CS)
return "cs";
if (code == CommonLanguages.CSCZ)
return "cs-CZ";
if (code == CommonLanguages.BS)
return "bs";
if (code == CommonLanguages.BSBA)
return "bs-BA";
if (code == CommonLanguages.DA)
return "da";
if (code == CommonLanguages.DADK)
return "da-DK";
if (code == CommonLanguages.DE)
return "de";
if (code == CommonLanguages.DEAT)
return "de-AT";
if (code == CommonLanguages.DECH)
return "de-CH";
if (code == CommonLanguages.DEDE)
return "de-DE";
if (code == CommonLanguages.EL)
return "el";
if (code == CommonLanguages.ELGR)
return "el-GR";
if (code == CommonLanguages.EN)
return "en";
if (code == CommonLanguages.ENAU)
return "en-AU";
if (code == CommonLanguages.ENCA)
return "en-CA";
if (code == CommonLanguages.ENGB)
return "en-GB";
if (code == CommonLanguages.ENIN)
return "en-IN";
if (code == CommonLanguages.ENNZ)
return "en-NZ";
if (code == CommonLanguages.ENSG)
return "en-SG";
if (code == CommonLanguages.ENUS)
return "en-US";
if (code == CommonLanguages.ES)
return "es";
if (code == CommonLanguages.ESAR)
return "es-AR";
if (code == CommonLanguages.ESES)
return "es-ES";
if (code == CommonLanguages.ESUY)
return "es-UY";
if (code == CommonLanguages.ET)
return "et";
if (code == CommonLanguages.ETEE)
return "et-EE";
if (code == CommonLanguages.FI)
return "fi";
if (code == CommonLanguages.FR)
return "fr";
if (code == CommonLanguages.FRBE)
return "fr-BE";
if (code == CommonLanguages.FRCH)
return "fr-CH";
if (code == CommonLanguages.FRFR)
return "fr-FR";
if (code == CommonLanguages.FIFI)
return "fi-FI";
if (code == CommonLanguages.FRCA)
return "fr-CA";
if (code == CommonLanguages.FY)
return "fy";
if (code == CommonLanguages.FYNL)
return "fy-NL";
if (code == CommonLanguages.HI)
return "hi";
if (code == CommonLanguages.HR)
return "hr";
if (code == CommonLanguages.HRHR)
return "hr-HR";
if (code == CommonLanguages.IS)
return "is";
if (code == CommonLanguages.ISIS)
return "is-IS";
if (code == CommonLanguages.IT)
return "it";
if (code == CommonLanguages.ITCH)
return "it-CH";
if (code == CommonLanguages.ITIT)
return "it-IT";
if (code == CommonLanguages.JA)
return "ja";
if (code == CommonLanguages.KO)
return "ko";
if (code == CommonLanguages.LT)
return "lt";
if (code == CommonLanguages.LTLT)
return "lt-LT";
if (code == CommonLanguages.LV)
return "lv";
if (code == CommonLanguages.LVLV)
return "lv-LV";
if (code == CommonLanguages.NL)
return "nl";
if (code == CommonLanguages.NLBE)
return "nl-BE";
if (code == CommonLanguages.NLNL)
return "nl-NL";
if (code == CommonLanguages.NO)
return "no";
if (code == CommonLanguages.NONO)
return "no-NO";
if (code == CommonLanguages.PA)
return "pa";
if (code == CommonLanguages.PL)
return "pl";
if (code == CommonLanguages.PLPL)
return "pl-PL";
if (code == CommonLanguages.PT)
return "pt";
if (code == CommonLanguages.PTPT)
return "pt-PT";
if (code == CommonLanguages.PTBR)
return "pt-BR";
if (code == CommonLanguages.RO)
return "ro";
if (code == CommonLanguages.RORO)
return "ro-RO";
if (code == CommonLanguages.RU)
return "ru";
if (code == CommonLanguages.RURU)
return "ru-RU";
if (code == CommonLanguages.SK)
return "sk";
if (code == CommonLanguages.SKSK)
return "sk-SK";
if (code == CommonLanguages.SL)
return "sl";
if (code == CommonLanguages.SLSI)
return "sl-SI";
if (code == CommonLanguages.SR)
return "sr";
if (code == CommonLanguages.SRRS)
return "sr-RS";
if (code == CommonLanguages.SV)
return "sv";
if (code == CommonLanguages.SVSE)
return "sv-SE";
if (code == CommonLanguages.TE)
return "te";
if (code == CommonLanguages.ZH)
return "zh";
if (code == CommonLanguages.ZHCN)
return "zh-CN";
if (code == CommonLanguages.ZHHK)
return "zh-HK";
if (code == CommonLanguages.ZHSG)
return "zh-SG";
if (code == CommonLanguages.ZHTW)
return "zh-TW";
return "?";
}
public String toSystem(CommonLanguages code) {
return code.getSystem();
}
}
public enum CompartmentType {
/**
* The compartment definition is for the patient compartment.
*/
PATIENT,
/**
* The compartment definition is for the encounter compartment.
*/
ENCOUNTER,
/**
* The compartment definition is for the related-person compartment.
*/
RELATEDPERSON,
/**
* The compartment definition is for the practitioner compartment.
*/
PRACTITIONER,
/**
* The compartment definition is for the device compartment.
*/
DEVICE,
/**
* The compartment definition is for the episodeofcare compartment.
*/
EPISODEOFCARE,
/**
* added to help the parsers
*/
GROUP,
/**
* added to help the parsers
*/
NULL;
public static CompartmentType fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("Patient".equals(codeString))
return PATIENT;
if ("Encounter".equals(codeString))
return ENCOUNTER;
if ("RelatedPerson".equals(codeString))
return RELATEDPERSON;
if ("Practitioner".equals(codeString))
return PRACTITIONER;
if ("Device".equals(codeString))
return DEVICE;
if ("EpisodeOfCare".equals(codeString))
return EPISODEOFCARE;
if ("Group".equals(codeString))
return GROUP;
throw new FHIRException("Unknown CompartmentType code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "Patient", "Encounter", "RelatedPerson", "Practitioner", "Device", "EpisodeOfCare");
}
public String toCode() {
switch (this) {
case PATIENT: return "Patient";
case ENCOUNTER: return "Encounter";
case RELATEDPERSON: return "RelatedPerson";
case PRACTITIONER: return "Practitioner";
case DEVICE: return "Device";
case EPISODEOFCARE: return "EpisodeOfCare";
case GROUP: return "Group";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case PATIENT: return "http://hl7.org/fhir/compartment-type";
case ENCOUNTER: return "http://hl7.org/fhir/compartment-type";
case RELATEDPERSON: return "http://hl7.org/fhir/compartment-type";
case PRACTITIONER: return "http://hl7.org/fhir/compartment-type";
case DEVICE: return "http://hl7.org/fhir/compartment-type";
case EPISODEOFCARE: return "http://hl7.org/fhir/compartment-type";
case GROUP: return "http://hl7.org/fhir/compartment-type";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case PATIENT: return "The compartment definition is for the patient compartment.";
case ENCOUNTER: return "The compartment definition is for the encounter compartment.";
case RELATEDPERSON: return "The compartment definition is for the related-person compartment.";
case PRACTITIONER: return "The compartment definition is for the practitioner compartment.";
case DEVICE: return "The compartment definition is for the device compartment.";
case EPISODEOFCARE: return "The compartment definition is for the episodeofcare compartment.";
case GROUP: return "The compartment definition is for the Group compartment.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case PATIENT: return "Patient";
case ENCOUNTER: return "Encounter";
case RELATEDPERSON: return "RelatedPerson";
case PRACTITIONER: return "Practitioner";
case DEVICE: return "Device";
case EPISODEOFCARE: return "EpisodeOfCare";
case GROUP: return "Group";
case NULL: return null;
default: return "?";
}
}
}
public static class CompartmentTypeEnumFactory implements EnumFactory {
public CompartmentType fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("Patient".equals(codeString))
return CompartmentType.PATIENT;
if ("Encounter".equals(codeString))
return CompartmentType.ENCOUNTER;
if ("RelatedPerson".equals(codeString))
return CompartmentType.RELATEDPERSON;
if ("Practitioner".equals(codeString))
return CompartmentType.PRACTITIONER;
if ("Device".equals(codeString))
return CompartmentType.DEVICE;
if ("EpisodeOfCare".equals(codeString))
return CompartmentType.EPISODEOFCARE;
if ("Group".equals(codeString))
return CompartmentType.GROUP;
throw new IllegalArgumentException("Unknown CompartmentType code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, CompartmentType.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, CompartmentType.NULL, code);
if ("Patient".equals(codeString))
return new Enumeration(this, CompartmentType.PATIENT, code);
if ("Encounter".equals(codeString))
return new Enumeration(this, CompartmentType.ENCOUNTER, code);
if ("RelatedPerson".equals(codeString))
return new Enumeration(this, CompartmentType.RELATEDPERSON, code);
if ("Practitioner".equals(codeString))
return new Enumeration(this, CompartmentType.PRACTITIONER, code);
if ("Device".equals(codeString))
return new Enumeration(this, CompartmentType.DEVICE, code);
if ("EpisodeOfCare".equals(codeString))
return new Enumeration(this, CompartmentType.EPISODEOFCARE, code);
if ("Group".equals(codeString))
return new Enumeration(this, CompartmentType.GROUP, code);
throw new FHIRException("Unknown CompartmentType code '"+codeString+"'");
}
public String toCode(CompartmentType code) {
if (code == CompartmentType.NULL)
return null;
if (code == CompartmentType.PATIENT)
return "Patient";
if (code == CompartmentType.ENCOUNTER)
return "Encounter";
if (code == CompartmentType.RELATEDPERSON)
return "RelatedPerson";
if (code == CompartmentType.PRACTITIONER)
return "Practitioner";
if (code == CompartmentType.DEVICE)
return "Device";
if (code == CompartmentType.EPISODEOFCARE)
return "EpisodeOfCare";
if (code == CompartmentType.GROUP)
return "Group";
return "?";
}
public String toSystem(CompartmentType code) {
return code.getSystem();
}
}
public enum CompositionStatus {
/**
* The existence of the composition is registered, but there is nothing yet available.
*/
REGISTERED,
/**
* This is a partial (e.g. initial, interim or preliminary) composition: data in the composition may be incomplete or unverified.
*/
PARTIAL,
/**
* Verified early results are available, but not all results are final.
*/
PRELIMINARY,
/**
* This version of the composition is complete and verified by an appropriate person and no further work is planned. Any subsequent updates would be on a new version of the composition.
*/
FINAL,
/**
* The composition content or the referenced resources have been modified (edited or added to) subsequent to being released as "final" and the composition is complete and verified by an authorized person.
*/
AMENDED,
/**
* Subsequent to being final, the composition content has been modified to correct an error in the composition or referenced results.
*/
CORRECTED,
/**
* Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged.
*/
APPENDED,
/**
* The composition is unavailable because the measurement was not started or not completed (also sometimes called "aborted").
*/
CANCELLED,
/**
* The composition or document was originally created/issued in error, and this is an amendment that marks that the entire series should not be considered as valid.
*/
ENTEREDINERROR,
/**
* This composition has been withdrawn or superseded and should no longer be used.
*/
DEPRECATED,
/**
* The authoring/source system does not know which of the status values currently applies for this observation. Note: This concept is not to be used for "other" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which.
*/
UNKNOWN,
/**
* added to help the parsers
*/
NULL;
public static CompositionStatus fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("registered".equals(codeString))
return REGISTERED;
if ("partial".equals(codeString))
return PARTIAL;
if ("preliminary".equals(codeString))
return PRELIMINARY;
if ("final".equals(codeString))
return FINAL;
if ("amended".equals(codeString))
return AMENDED;
if ("corrected".equals(codeString))
return CORRECTED;
if ("appended".equals(codeString))
return APPENDED;
if ("cancelled".equals(codeString))
return CANCELLED;
if ("entered-in-error".equals(codeString))
return ENTEREDINERROR;
if ("deprecated".equals(codeString))
return DEPRECATED;
if ("unknown".equals(codeString))
return UNKNOWN;
throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "registered", "partial", "preliminary", "final", "amended", "corrected", "appended", "cancelled", "entered-in-error", "deprecated", "unknown");
}
public String toCode() {
switch (this) {
case REGISTERED: return "registered";
case PARTIAL: return "partial";
case PRELIMINARY: return "preliminary";
case FINAL: return "final";
case AMENDED: return "amended";
case CORRECTED: return "corrected";
case APPENDED: return "appended";
case CANCELLED: return "cancelled";
case ENTEREDINERROR: return "entered-in-error";
case DEPRECATED: return "deprecated";
case UNKNOWN: return "unknown";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case REGISTERED: return "http://hl7.org/fhir/composition-status";
case PARTIAL: return "http://hl7.org/fhir/composition-status";
case PRELIMINARY: return "http://hl7.org/fhir/composition-status";
case FINAL: return "http://hl7.org/fhir/composition-status";
case AMENDED: return "http://hl7.org/fhir/composition-status";
case CORRECTED: return "http://hl7.org/fhir/composition-status";
case APPENDED: return "http://hl7.org/fhir/composition-status";
case CANCELLED: return "http://hl7.org/fhir/composition-status";
case ENTEREDINERROR: return "http://hl7.org/fhir/composition-status";
case DEPRECATED: return "http://hl7.org/fhir/composition-status";
case UNKNOWN: return "http://hl7.org/fhir/composition-status";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case REGISTERED: return "The existence of the composition is registered, but there is nothing yet available.";
case PARTIAL: return "This is a partial (e.g. initial, interim or preliminary) composition: data in the composition may be incomplete or unverified.";
case PRELIMINARY: return "Verified early results are available, but not all results are final.";
case FINAL: return "This version of the composition is complete and verified by an appropriate person and no further work is planned. Any subsequent updates would be on a new version of the composition.";
case AMENDED: return "The composition content or the referenced resources have been modified (edited or added to) subsequent to being released as \"final\" and the composition is complete and verified by an authorized person.";
case CORRECTED: return "Subsequent to being final, the composition content has been modified to correct an error in the composition or referenced results.";
case APPENDED: return "Subsequent to being final, the composition content has been modified by adding new content. The existing content is unchanged.";
case CANCELLED: return "The composition is unavailable because the measurement was not started or not completed (also sometimes called \"aborted\").";
case ENTEREDINERROR: return "The composition or document was originally created/issued in error, and this is an amendment that marks that the entire series should not be considered as valid.";
case DEPRECATED: return "This composition has been withdrawn or superseded and should no longer be used.";
case UNKNOWN: return "The authoring/source system does not know which of the status values currently applies for this observation. Note: This concept is not to be used for \"other\" - one of the listed statuses is presumed to apply, but the authoring/source system does not know which.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case REGISTERED: return "Registered";
case PARTIAL: return "Partial";
case PRELIMINARY: return "Preliminary";
case FINAL: return "Final";
case AMENDED: return "Amended";
case CORRECTED: return "Corrected";
case APPENDED: return "Appended";
case CANCELLED: return "Cancelled";
case ENTEREDINERROR: return "Entered in Error";
case DEPRECATED: return "Deprecated";
case UNKNOWN: return "Unknown";
case NULL: return null;
default: return "?";
}
}
}
public static class CompositionStatusEnumFactory implements EnumFactory {
public CompositionStatus fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("registered".equals(codeString))
return CompositionStatus.REGISTERED;
if ("partial".equals(codeString))
return CompositionStatus.PARTIAL;
if ("preliminary".equals(codeString))
return CompositionStatus.PRELIMINARY;
if ("final".equals(codeString))
return CompositionStatus.FINAL;
if ("amended".equals(codeString))
return CompositionStatus.AMENDED;
if ("corrected".equals(codeString))
return CompositionStatus.CORRECTED;
if ("appended".equals(codeString))
return CompositionStatus.APPENDED;
if ("cancelled".equals(codeString))
return CompositionStatus.CANCELLED;
if ("entered-in-error".equals(codeString))
return CompositionStatus.ENTEREDINERROR;
if ("deprecated".equals(codeString))
return CompositionStatus.DEPRECATED;
if ("unknown".equals(codeString))
return CompositionStatus.UNKNOWN;
throw new IllegalArgumentException("Unknown CompositionStatus code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, CompositionStatus.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, CompositionStatus.NULL, code);
if ("registered".equals(codeString))
return new Enumeration(this, CompositionStatus.REGISTERED, code);
if ("partial".equals(codeString))
return new Enumeration(this, CompositionStatus.PARTIAL, code);
if ("preliminary".equals(codeString))
return new Enumeration(this, CompositionStatus.PRELIMINARY, code);
if ("final".equals(codeString))
return new Enumeration(this, CompositionStatus.FINAL, code);
if ("amended".equals(codeString))
return new Enumeration(this, CompositionStatus.AMENDED, code);
if ("corrected".equals(codeString))
return new Enumeration(this, CompositionStatus.CORRECTED, code);
if ("appended".equals(codeString))
return new Enumeration(this, CompositionStatus.APPENDED, code);
if ("cancelled".equals(codeString))
return new Enumeration(this, CompositionStatus.CANCELLED, code);
if ("entered-in-error".equals(codeString))
return new Enumeration(this, CompositionStatus.ENTEREDINERROR, code);
if ("deprecated".equals(codeString))
return new Enumeration(this, CompositionStatus.DEPRECATED, code);
if ("unknown".equals(codeString))
return new Enumeration(this, CompositionStatus.UNKNOWN, code);
throw new FHIRException("Unknown CompositionStatus code '"+codeString+"'");
}
public String toCode(CompositionStatus code) {
if (code == CompositionStatus.NULL)
return null;
if (code == CompositionStatus.REGISTERED)
return "registered";
if (code == CompositionStatus.PARTIAL)
return "partial";
if (code == CompositionStatus.PRELIMINARY)
return "preliminary";
if (code == CompositionStatus.FINAL)
return "final";
if (code == CompositionStatus.AMENDED)
return "amended";
if (code == CompositionStatus.CORRECTED)
return "corrected";
if (code == CompositionStatus.APPENDED)
return "appended";
if (code == CompositionStatus.CANCELLED)
return "cancelled";
if (code == CompositionStatus.ENTEREDINERROR)
return "entered-in-error";
if (code == CompositionStatus.DEPRECATED)
return "deprecated";
if (code == CompositionStatus.UNKNOWN)
return "unknown";
return "?";
}
public String toSystem(CompositionStatus code) {
return code.getSystem();
}
}
public enum ConceptMapRelationship {
/**
* The concepts are related to each other, but the exact relationship is not known.
*/
RELATEDTO,
/**
* The definitions of the concepts mean the same thing.
*/
EQUIVALENT,
/**
* The source concept is narrower in meaning than the target concept.
*/
SOURCEISNARROWERTHANTARGET,
/**
* The source concept is broader in meaning than the target concept.
*/
SOURCEISBROADERTHANTARGET,
/**
* This is an explicit assertion that the target concept is not related to the source concept.
*/
NOTRELATEDTO,
/**
* added to help the parsers
*/
NULL;
public static ConceptMapRelationship fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("related-to".equals(codeString))
return RELATEDTO;
if ("equivalent".equals(codeString))
return EQUIVALENT;
if ("source-is-narrower-than-target".equals(codeString))
return SOURCEISNARROWERTHANTARGET;
if ("source-is-broader-than-target".equals(codeString))
return SOURCEISBROADERTHANTARGET;
if ("not-related-to".equals(codeString))
return NOTRELATEDTO;
throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "related-to", "equivalent", "source-is-narrower-than-target", "source-is-broader-than-target", "not-related-to");
}
public String toCode() {
switch (this) {
case RELATEDTO: return "related-to";
case EQUIVALENT: return "equivalent";
case SOURCEISNARROWERTHANTARGET: return "source-is-narrower-than-target";
case SOURCEISBROADERTHANTARGET: return "source-is-broader-than-target";
case NOTRELATEDTO: return "not-related-to";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case RELATEDTO: return "http://hl7.org/fhir/concept-map-relationship";
case EQUIVALENT: return "http://hl7.org/fhir/concept-map-relationship";
case SOURCEISNARROWERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship";
case SOURCEISBROADERTHANTARGET: return "http://hl7.org/fhir/concept-map-relationship";
case NOTRELATEDTO: return "http://hl7.org/fhir/concept-map-relationship";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case RELATEDTO: return "The concepts are related to each other, but the exact relationship is not known.";
case EQUIVALENT: return "The definitions of the concepts mean the same thing.";
case SOURCEISNARROWERTHANTARGET: return "The source concept is narrower in meaning than the target concept.";
case SOURCEISBROADERTHANTARGET: return "The source concept is broader in meaning than the target concept.";
case NOTRELATEDTO: return "This is an explicit assertion that the target concept is not related to the source concept.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case RELATEDTO: return "Related To";
case EQUIVALENT: return "Equivalent";
case SOURCEISNARROWERTHANTARGET: return "Source Is Narrower Than Target";
case SOURCEISBROADERTHANTARGET: return "Source Is Broader Than Target";
case NOTRELATEDTO: return "Not Related To";
case NULL: return null;
default: return "?";
}
}
public String getSymbol() {
switch (this) {
case RELATEDTO: return "-";
case EQUIVALENT: return "=";
case SOURCEISNARROWERTHANTARGET: return "<";
case SOURCEISBROADERTHANTARGET: return ">";
case NOTRELATEDTO: return "!=";
case NULL: return null;
default: return "?";
}
}
}
public static class ConceptMapRelationshipEnumFactory implements EnumFactory {
public ConceptMapRelationship fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("related-to".equals(codeString))
return ConceptMapRelationship.RELATEDTO;
if ("equivalent".equals(codeString))
return ConceptMapRelationship.EQUIVALENT;
if ("source-is-narrower-than-target".equals(codeString))
return ConceptMapRelationship.SOURCEISNARROWERTHANTARGET;
if ("source-is-broader-than-target".equals(codeString))
return ConceptMapRelationship.SOURCEISBROADERTHANTARGET;
if ("not-related-to".equals(codeString))
return ConceptMapRelationship.NOTRELATEDTO;
throw new IllegalArgumentException("Unknown ConceptMapRelationship code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ConceptMapRelationship.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ConceptMapRelationship.NULL, code);
if ("related-to".equals(codeString))
return new Enumeration(this, ConceptMapRelationship.RELATEDTO, code);
if ("equivalent".equals(codeString))
return new Enumeration(this, ConceptMapRelationship.EQUIVALENT, code);
if ("source-is-narrower-than-target".equals(codeString))
return new Enumeration(this, ConceptMapRelationship.SOURCEISNARROWERTHANTARGET, code);
if ("source-is-broader-than-target".equals(codeString))
return new Enumeration(this, ConceptMapRelationship.SOURCEISBROADERTHANTARGET, code);
if ("not-related-to".equals(codeString))
return new Enumeration(this, ConceptMapRelationship.NOTRELATEDTO, code);
throw new FHIRException("Unknown ConceptMapRelationship code '"+codeString+"'");
}
public String toCode(ConceptMapRelationship code) {
if (code == ConceptMapRelationship.NULL)
return null;
if (code == ConceptMapRelationship.RELATEDTO)
return "related-to";
if (code == ConceptMapRelationship.EQUIVALENT)
return "equivalent";
if (code == ConceptMapRelationship.SOURCEISNARROWERTHANTARGET)
return "source-is-narrower-than-target";
if (code == ConceptMapRelationship.SOURCEISBROADERTHANTARGET)
return "source-is-broader-than-target";
if (code == ConceptMapRelationship.NOTRELATEDTO)
return "not-related-to";
return "?";
}
public String toSystem(ConceptMapRelationship code) {
return code.getSystem();
}
}
public enum ConsentDataMeaning {
/**
* The consent applies directly to the instance of the resource.
*/
INSTANCE,
/**
* The consent applies directly to the instance of the resource and instances it refers to.
*/
RELATED,
/**
* The consent applies directly to the instance of the resource and instances that refer to it.
*/
DEPENDENTS,
/**
* The consent applies to instances of resources that are authored by.
*/
AUTHOREDBY,
/**
* added to help the parsers
*/
NULL;
public static ConsentDataMeaning fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("instance".equals(codeString))
return INSTANCE;
if ("related".equals(codeString))
return RELATED;
if ("dependents".equals(codeString))
return DEPENDENTS;
if ("authoredby".equals(codeString))
return AUTHOREDBY;
throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "instance", "related", "dependents", "authoredby");
}
public String toCode() {
switch (this) {
case INSTANCE: return "instance";
case RELATED: return "related";
case DEPENDENTS: return "dependents";
case AUTHOREDBY: return "authoredby";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case INSTANCE: return "http://hl7.org/fhir/consent-data-meaning";
case RELATED: return "http://hl7.org/fhir/consent-data-meaning";
case DEPENDENTS: return "http://hl7.org/fhir/consent-data-meaning";
case AUTHOREDBY: return "http://hl7.org/fhir/consent-data-meaning";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case INSTANCE: return "The consent applies directly to the instance of the resource.";
case RELATED: return "The consent applies directly to the instance of the resource and instances it refers to.";
case DEPENDENTS: return "The consent applies directly to the instance of the resource and instances that refer to it.";
case AUTHOREDBY: return "The consent applies to instances of resources that are authored by.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case INSTANCE: return "Instance";
case RELATED: return "Related";
case DEPENDENTS: return "Dependents";
case AUTHOREDBY: return "AuthoredBy";
case NULL: return null;
default: return "?";
}
}
}
public static class ConsentDataMeaningEnumFactory implements EnumFactory {
public ConsentDataMeaning fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("instance".equals(codeString))
return ConsentDataMeaning.INSTANCE;
if ("related".equals(codeString))
return ConsentDataMeaning.RELATED;
if ("dependents".equals(codeString))
return ConsentDataMeaning.DEPENDENTS;
if ("authoredby".equals(codeString))
return ConsentDataMeaning.AUTHOREDBY;
throw new IllegalArgumentException("Unknown ConsentDataMeaning code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ConsentDataMeaning.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ConsentDataMeaning.NULL, code);
if ("instance".equals(codeString))
return new Enumeration(this, ConsentDataMeaning.INSTANCE, code);
if ("related".equals(codeString))
return new Enumeration(this, ConsentDataMeaning.RELATED, code);
if ("dependents".equals(codeString))
return new Enumeration(this, ConsentDataMeaning.DEPENDENTS, code);
if ("authoredby".equals(codeString))
return new Enumeration(this, ConsentDataMeaning.AUTHOREDBY, code);
throw new FHIRException("Unknown ConsentDataMeaning code '"+codeString+"'");
}
public String toCode(ConsentDataMeaning code) {
if (code == ConsentDataMeaning.NULL)
return null;
if (code == ConsentDataMeaning.INSTANCE)
return "instance";
if (code == ConsentDataMeaning.RELATED)
return "related";
if (code == ConsentDataMeaning.DEPENDENTS)
return "dependents";
if (code == ConsentDataMeaning.AUTHOREDBY)
return "authoredby";
return "?";
}
public String toSystem(ConsentDataMeaning code) {
return code.getSystem();
}
}
public enum ConsentProvisionType {
/**
* Consent is denied for actions meeting these rules.
*/
DENY,
/**
* Consent is provided for actions meeting these rules.
*/
PERMIT,
/**
* added to help the parsers
*/
NULL;
public static ConsentProvisionType fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("deny".equals(codeString))
return DENY;
if ("permit".equals(codeString))
return PERMIT;
throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "deny", "permit");
}
public String toCode() {
switch (this) {
case DENY: return "deny";
case PERMIT: return "permit";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case DENY: return "http://hl7.org/fhir/consent-provision-type";
case PERMIT: return "http://hl7.org/fhir/consent-provision-type";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case DENY: return "Consent is denied for actions meeting these rules.";
case PERMIT: return "Consent is provided for actions meeting these rules.";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case DENY: return "Deny";
case PERMIT: return "Permit";
case NULL: return null;
default: return "?";
}
}
}
public static class ConsentProvisionTypeEnumFactory implements EnumFactory {
public ConsentProvisionType fromCode(String codeString) throws IllegalArgumentException {
if (codeString == null || "".equals(codeString))
if (codeString == null || "".equals(codeString))
return null;
if ("deny".equals(codeString))
return ConsentProvisionType.DENY;
if ("permit".equals(codeString))
return ConsentProvisionType.PERMIT;
throw new IllegalArgumentException("Unknown ConsentProvisionType code '"+codeString+"'");
}
public Enumeration fromType(PrimitiveType code) throws FHIRException {
if (code == null)
return null;
if (code.isEmpty())
return new Enumeration(this, ConsentProvisionType.NULL, code);
String codeString = ((PrimitiveType) code).asStringValue();
if (codeString == null || "".equals(codeString))
return new Enumeration(this, ConsentProvisionType.NULL, code);
if ("deny".equals(codeString))
return new Enumeration(this, ConsentProvisionType.DENY, code);
if ("permit".equals(codeString))
return new Enumeration(this, ConsentProvisionType.PERMIT, code);
throw new FHIRException("Unknown ConsentProvisionType code '"+codeString+"'");
}
public String toCode(ConsentProvisionType code) {
if (code == ConsentProvisionType.NULL)
return null;
if (code == ConsentProvisionType.DENY)
return "deny";
if (code == ConsentProvisionType.PERMIT)
return "permit";
return "?";
}
public String toSystem(ConsentProvisionType code) {
return code.getSystem();
}
}
public enum Currencies {
/**
* null
*/
AED,
/**
* null
*/
AFN,
/**
* null
*/
ALL,
/**
* null
*/
AMD,
/**
* null
*/
ANG,
/**
* null
*/
AOA,
/**
* null
*/
ARS,
/**
* null
*/
AUD,
/**
* null
*/
AWG,
/**
* null
*/
AZN,
/**
* null
*/
BAM,
/**
* null
*/
BBD,
/**
* null
*/
BDT,
/**
* null
*/
BGN,
/**
* null
*/
BHD,
/**
* null
*/
BIF,
/**
* null
*/
BMD,
/**
* null
*/
BND,
/**
* null
*/
BOB,
/**
* null
*/
BOV,
/**
* null
*/
BRL,
/**
* null
*/
BSD,
/**
* null
*/
BTN,
/**
* null
*/
BWP,
/**
* null
*/
BYN,
/**
* null
*/
BZD,
/**
* null
*/
CAD,
/**
* null
*/
CDF,
/**
* null
*/
CHE,
/**
* null
*/
CHF,
/**
* null
*/
CHW,
/**
* null
*/
CLF,
/**
* null
*/
CLP,
/**
* null
*/
CNY,
/**
* null
*/
COP,
/**
* null
*/
COU,
/**
* null
*/
CRC,
/**
* null
*/
CUC,
/**
* null
*/
CUP,
/**
* null
*/
CVE,
/**
* null
*/
CZK,
/**
* null
*/
DJF,
/**
* null
*/
DKK,
/**
* null
*/
DOP,
/**
* null
*/
DZD,
/**
* null
*/
EGP,
/**
* null
*/
ERN,
/**
* null
*/
ETB,
/**
* null
*/
EUR,
/**
* null
*/
FJD,
/**
* null
*/
FKP,
/**
* null
*/
GBP,
/**
* null
*/
GEL,
/**
* null
*/
GGP,
/**
* null
*/
GHS,
/**
* null
*/
GIP,
/**
* null
*/
GMD,
/**
* null
*/
GNF,
/**
* null
*/
GTQ,
/**
* null
*/
GYD,
/**
* null
*/
HKD,
/**
* null
*/
HNL,
/**
* null
*/
HRK,
/**
* null
*/
HTG,
/**
* null
*/
HUF,
/**
* null
*/
IDR,
/**
* null
*/
ILS,
/**
* null
*/
IMP,
/**
* null
*/
INR,
/**
* null
*/
IQD,
/**
* null
*/
IRR,
/**
* null
*/
ISK,
/**
* null
*/
JEP,
/**
* null
*/
JMD,
/**
* null
*/
JOD,
/**
* null
*/
JPY,
/**
* null
*/
KES,
/**
* null
*/
KGS,
/**
* null
*/
KHR,
/**
* null
*/
KMF,
/**
* null
*/
KPW,
/**
* null
*/
KRW,
/**
* null
*/
KWD,
/**
* null
*/
KYD,
/**
* null
*/
KZT,
/**
* null
*/
LAK,
/**
* null
*/
LBP,
/**
* null
*/
LKR,
/**
* null
*/
LRD,
/**
* null
*/
LSL,
/**
* null
*/
LYD,
/**
* null
*/
MAD,
/**
* null
*/
MDL,
/**
* null
*/
MGA,
/**
* null
*/
MKD,
/**
* null
*/
MMK,
/**
* null
*/
MNT,
/**
* null
*/
MOP,
/**
* null
*/
MRU,
/**
* null
*/
MUR,
/**
* null
*/
MVR,
/**
* null
*/
MWK,
/**
* null
*/
MXN,
/**
* null
*/
MXV,
/**
* null
*/
MYR,
/**
* null
*/
MZN,
/**
* null
*/
NAD,
/**
* null
*/
NGN,
/**
* null
*/
NIO,
/**
* null
*/
NOK,
/**
* null
*/
NPR,
/**
* null
*/
NZD,
/**
* null
*/
OMR,
/**
* null
*/
PAB,
/**
* null
*/
PEN,
/**
* null
*/
PGK,
/**
* null
*/
PHP,
/**
* null
*/
PKR,
/**
* null
*/
PLN,
/**
* null
*/
PYG,
/**
* null
*/
QAR,
/**
* null
*/
RON,
/**
* null
*/
RSD,
/**
* null
*/
RUB,
/**
* null
*/
RWF,
/**
* null
*/
SAR,
/**
* null
*/
SBD,
/**
* null
*/
SCR,
/**
* null
*/
SDG,
/**
* null
*/
SEK,
/**
* null
*/
SGD,
/**
* null
*/
SHP,
/**
* null
*/
SLL,
/**
* null
*/
SOS,
/**
* null
*/
SRD,
/**
* null
*/
SSP,
/**
* null
*/
STN,
/**
* null
*/
SVC,
/**
* null
*/
SYP,
/**
* null
*/
SZL,
/**
* null
*/
THB,
/**
* null
*/
TJS,
/**
* null
*/
TMT,
/**
* null
*/
TND,
/**
* null
*/
TOP,
/**
* null
*/
TRY,
/**
* null
*/
TTD,
/**
* null
*/
TVD,
/**
* null
*/
TWD,
/**
* null
*/
TZS,
/**
* null
*/
UAH,
/**
* null
*/
UGX,
/**
* null
*/
USD,
/**
* null
*/
USN,
/**
* null
*/
UYI,
/**
* null
*/
UYU,
/**
* null
*/
UZS,
/**
* null
*/
VEF,
/**
* null
*/
VND,
/**
* null
*/
VUV,
/**
* null
*/
WST,
/**
* null
*/
XAF,
/**
* null
*/
XAG,
/**
* null
*/
XAU,
/**
* null
*/
XBA,
/**
* null
*/
XBB,
/**
* null
*/
XBC,
/**
* null
*/
XBD,
/**
* null
*/
XCD,
/**
* null
*/
XDR,
/**
* null
*/
XOF,
/**
* null
*/
XPD,
/**
* null
*/
XPF,
/**
* null
*/
XPT,
/**
* null
*/
XSU,
/**
* null
*/
XTS,
/**
* null
*/
XUA,
/**
* null
*/
XXX,
/**
* null
*/
YER,
/**
* null
*/
ZAR,
/**
* null
*/
ZMW,
/**
* null
*/
ZWL,
/**
* added to help the parsers
*/
NULL;
public static Currencies fromCode(String codeString) throws FHIRException {
if (codeString == null || "".equals(codeString))
return null;
if ("AED".equals(codeString))
return AED;
if ("AFN".equals(codeString))
return AFN;
if ("ALL".equals(codeString))
return ALL;
if ("AMD".equals(codeString))
return AMD;
if ("ANG".equals(codeString))
return ANG;
if ("AOA".equals(codeString))
return AOA;
if ("ARS".equals(codeString))
return ARS;
if ("AUD".equals(codeString))
return AUD;
if ("AWG".equals(codeString))
return AWG;
if ("AZN".equals(codeString))
return AZN;
if ("BAM".equals(codeString))
return BAM;
if ("BBD".equals(codeString))
return BBD;
if ("BDT".equals(codeString))
return BDT;
if ("BGN".equals(codeString))
return BGN;
if ("BHD".equals(codeString))
return BHD;
if ("BIF".equals(codeString))
return BIF;
if ("BMD".equals(codeString))
return BMD;
if ("BND".equals(codeString))
return BND;
if ("BOB".equals(codeString))
return BOB;
if ("BOV".equals(codeString))
return BOV;
if ("BRL".equals(codeString))
return BRL;
if ("BSD".equals(codeString))
return BSD;
if ("BTN".equals(codeString))
return BTN;
if ("BWP".equals(codeString))
return BWP;
if ("BYN".equals(codeString))
return BYN;
if ("BZD".equals(codeString))
return BZD;
if ("CAD".equals(codeString))
return CAD;
if ("CDF".equals(codeString))
return CDF;
if ("CHE".equals(codeString))
return CHE;
if ("CHF".equals(codeString))
return CHF;
if ("CHW".equals(codeString))
return CHW;
if ("CLF".equals(codeString))
return CLF;
if ("CLP".equals(codeString))
return CLP;
if ("CNY".equals(codeString))
return CNY;
if ("COP".equals(codeString))
return COP;
if ("COU".equals(codeString))
return COU;
if ("CRC".equals(codeString))
return CRC;
if ("CUC".equals(codeString))
return CUC;
if ("CUP".equals(codeString))
return CUP;
if ("CVE".equals(codeString))
return CVE;
if ("CZK".equals(codeString))
return CZK;
if ("DJF".equals(codeString))
return DJF;
if ("DKK".equals(codeString))
return DKK;
if ("DOP".equals(codeString))
return DOP;
if ("DZD".equals(codeString))
return DZD;
if ("EGP".equals(codeString))
return EGP;
if ("ERN".equals(codeString))
return ERN;
if ("ETB".equals(codeString))
return ETB;
if ("EUR".equals(codeString))
return EUR;
if ("FJD".equals(codeString))
return FJD;
if ("FKP".equals(codeString))
return FKP;
if ("GBP".equals(codeString))
return GBP;
if ("GEL".equals(codeString))
return GEL;
if ("GGP".equals(codeString))
return GGP;
if ("GHS".equals(codeString))
return GHS;
if ("GIP".equals(codeString))
return GIP;
if ("GMD".equals(codeString))
return GMD;
if ("GNF".equals(codeString))
return GNF;
if ("GTQ".equals(codeString))
return GTQ;
if ("GYD".equals(codeString))
return GYD;
if ("HKD".equals(codeString))
return HKD;
if ("HNL".equals(codeString))
return HNL;
if ("HRK".equals(codeString))
return HRK;
if ("HTG".equals(codeString))
return HTG;
if ("HUF".equals(codeString))
return HUF;
if ("IDR".equals(codeString))
return IDR;
if ("ILS".equals(codeString))
return ILS;
if ("IMP".equals(codeString))
return IMP;
if ("INR".equals(codeString))
return INR;
if ("IQD".equals(codeString))
return IQD;
if ("IRR".equals(codeString))
return IRR;
if ("ISK".equals(codeString))
return ISK;
if ("JEP".equals(codeString))
return JEP;
if ("JMD".equals(codeString))
return JMD;
if ("JOD".equals(codeString))
return JOD;
if ("JPY".equals(codeString))
return JPY;
if ("KES".equals(codeString))
return KES;
if ("KGS".equals(codeString))
return KGS;
if ("KHR".equals(codeString))
return KHR;
if ("KMF".equals(codeString))
return KMF;
if ("KPW".equals(codeString))
return KPW;
if ("KRW".equals(codeString))
return KRW;
if ("KWD".equals(codeString))
return KWD;
if ("KYD".equals(codeString))
return KYD;
if ("KZT".equals(codeString))
return KZT;
if ("LAK".equals(codeString))
return LAK;
if ("LBP".equals(codeString))
return LBP;
if ("LKR".equals(codeString))
return LKR;
if ("LRD".equals(codeString))
return LRD;
if ("LSL".equals(codeString))
return LSL;
if ("LYD".equals(codeString))
return LYD;
if ("MAD".equals(codeString))
return MAD;
if ("MDL".equals(codeString))
return MDL;
if ("MGA".equals(codeString))
return MGA;
if ("MKD".equals(codeString))
return MKD;
if ("MMK".equals(codeString))
return MMK;
if ("MNT".equals(codeString))
return MNT;
if ("MOP".equals(codeString))
return MOP;
if ("MRU".equals(codeString))
return MRU;
if ("MUR".equals(codeString))
return MUR;
if ("MVR".equals(codeString))
return MVR;
if ("MWK".equals(codeString))
return MWK;
if ("MXN".equals(codeString))
return MXN;
if ("MXV".equals(codeString))
return MXV;
if ("MYR".equals(codeString))
return MYR;
if ("MZN".equals(codeString))
return MZN;
if ("NAD".equals(codeString))
return NAD;
if ("NGN".equals(codeString))
return NGN;
if ("NIO".equals(codeString))
return NIO;
if ("NOK".equals(codeString))
return NOK;
if ("NPR".equals(codeString))
return NPR;
if ("NZD".equals(codeString))
return NZD;
if ("OMR".equals(codeString))
return OMR;
if ("PAB".equals(codeString))
return PAB;
if ("PEN".equals(codeString))
return PEN;
if ("PGK".equals(codeString))
return PGK;
if ("PHP".equals(codeString))
return PHP;
if ("PKR".equals(codeString))
return PKR;
if ("PLN".equals(codeString))
return PLN;
if ("PYG".equals(codeString))
return PYG;
if ("QAR".equals(codeString))
return QAR;
if ("RON".equals(codeString))
return RON;
if ("RSD".equals(codeString))
return RSD;
if ("RUB".equals(codeString))
return RUB;
if ("RWF".equals(codeString))
return RWF;
if ("SAR".equals(codeString))
return SAR;
if ("SBD".equals(codeString))
return SBD;
if ("SCR".equals(codeString))
return SCR;
if ("SDG".equals(codeString))
return SDG;
if ("SEK".equals(codeString))
return SEK;
if ("SGD".equals(codeString))
return SGD;
if ("SHP".equals(codeString))
return SHP;
if ("SLL".equals(codeString))
return SLL;
if ("SOS".equals(codeString))
return SOS;
if ("SRD".equals(codeString))
return SRD;
if ("SSP".equals(codeString))
return SSP;
if ("STN".equals(codeString))
return STN;
if ("SVC".equals(codeString))
return SVC;
if ("SYP".equals(codeString))
return SYP;
if ("SZL".equals(codeString))
return SZL;
if ("THB".equals(codeString))
return THB;
if ("TJS".equals(codeString))
return TJS;
if ("TMT".equals(codeString))
return TMT;
if ("TND".equals(codeString))
return TND;
if ("TOP".equals(codeString))
return TOP;
if ("TRY".equals(codeString))
return TRY;
if ("TTD".equals(codeString))
return TTD;
if ("TVD".equals(codeString))
return TVD;
if ("TWD".equals(codeString))
return TWD;
if ("TZS".equals(codeString))
return TZS;
if ("UAH".equals(codeString))
return UAH;
if ("UGX".equals(codeString))
return UGX;
if ("USD".equals(codeString))
return USD;
if ("USN".equals(codeString))
return USN;
if ("UYI".equals(codeString))
return UYI;
if ("UYU".equals(codeString))
return UYU;
if ("UZS".equals(codeString))
return UZS;
if ("VEF".equals(codeString))
return VEF;
if ("VND".equals(codeString))
return VND;
if ("VUV".equals(codeString))
return VUV;
if ("WST".equals(codeString))
return WST;
if ("XAF".equals(codeString))
return XAF;
if ("XAG".equals(codeString))
return XAG;
if ("XAU".equals(codeString))
return XAU;
if ("XBA".equals(codeString))
return XBA;
if ("XBB".equals(codeString))
return XBB;
if ("XBC".equals(codeString))
return XBC;
if ("XBD".equals(codeString))
return XBD;
if ("XCD".equals(codeString))
return XCD;
if ("XDR".equals(codeString))
return XDR;
if ("XOF".equals(codeString))
return XOF;
if ("XPD".equals(codeString))
return XPD;
if ("XPF".equals(codeString))
return XPF;
if ("XPT".equals(codeString))
return XPT;
if ("XSU".equals(codeString))
return XSU;
if ("XTS".equals(codeString))
return XTS;
if ("XUA".equals(codeString))
return XUA;
if ("XXX".equals(codeString))
return XXX;
if ("YER".equals(codeString))
return YER;
if ("ZAR".equals(codeString))
return ZAR;
if ("ZMW".equals(codeString))
return ZMW;
if ("ZWL".equals(codeString))
return ZWL;
throw new FHIRException("Unknown Currencies code '"+codeString+"'");
}
public static boolean isValidCode(String codeString) {
if (codeString == null || "".equals(codeString))
return false;
return Utilities.existsInList(codeString, "AED", "AFN", "ALL", "AMD", "ANG", "AOA", "ARS", "AUD", "AWG", "AZN", "BAM", "BBD", "BDT", "BGN", "BHD", "BIF", "BMD", "BND", "BOB", "BOV", "BRL", "BSD", "BTN", "BWP", "BYN", "BZD", "CAD", "CDF", "CHE", "CHF", "CHW", "CLF", "CLP", "CNY", "COP", "COU", "CRC", "CUC", "CUP", "CVE", "CZK", "DJF", "DKK", "DOP", "DZD", "EGP", "ERN", "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GGP", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD", "HKD", "HNL", "HRK", "HTG", "HUF", "IDR", "ILS", "IMP", "INR", "IQD", "IRR", "ISK", "JEP", "JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LYD", "MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRU", "MUR", "MVR", "MWK", "MXN", "MXV", "MYR", "MZN", "NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN", "PYG", "QAR", "RON", "RSD", "RUB", "RWF", "SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SLL", "SOS", "SRD", "SSP", "STN", "SVC", "SYP", "SZL", "THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TVD", "TWD", "TZS", "UAH", "UGX", "USD", "USN", "UYI", "UYU", "UZS", "VEF", "VND", "VUV", "WST", "XAF", "XAG", "XAU", "XBA", "XBB", "XBC", "XBD", "XCD", "XDR", "XOF", "XPD", "XPF", "XPT", "XSU", "XTS", "XUA", "XXX", "YER", "ZAR", "ZMW", "ZWL");
}
public String toCode() {
switch (this) {
case AED: return "AED";
case AFN: return "AFN";
case ALL: return "ALL";
case AMD: return "AMD";
case ANG: return "ANG";
case AOA: return "AOA";
case ARS: return "ARS";
case AUD: return "AUD";
case AWG: return "AWG";
case AZN: return "AZN";
case BAM: return "BAM";
case BBD: return "BBD";
case BDT: return "BDT";
case BGN: return "BGN";
case BHD: return "BHD";
case BIF: return "BIF";
case BMD: return "BMD";
case BND: return "BND";
case BOB: return "BOB";
case BOV: return "BOV";
case BRL: return "BRL";
case BSD: return "BSD";
case BTN: return "BTN";
case BWP: return "BWP";
case BYN: return "BYN";
case BZD: return "BZD";
case CAD: return "CAD";
case CDF: return "CDF";
case CHE: return "CHE";
case CHF: return "CHF";
case CHW: return "CHW";
case CLF: return "CLF";
case CLP: return "CLP";
case CNY: return "CNY";
case COP: return "COP";
case COU: return "COU";
case CRC: return "CRC";
case CUC: return "CUC";
case CUP: return "CUP";
case CVE: return "CVE";
case CZK: return "CZK";
case DJF: return "DJF";
case DKK: return "DKK";
case DOP: return "DOP";
case DZD: return "DZD";
case EGP: return "EGP";
case ERN: return "ERN";
case ETB: return "ETB";
case EUR: return "EUR";
case FJD: return "FJD";
case FKP: return "FKP";
case GBP: return "GBP";
case GEL: return "GEL";
case GGP: return "GGP";
case GHS: return "GHS";
case GIP: return "GIP";
case GMD: return "GMD";
case GNF: return "GNF";
case GTQ: return "GTQ";
case GYD: return "GYD";
case HKD: return "HKD";
case HNL: return "HNL";
case HRK: return "HRK";
case HTG: return "HTG";
case HUF: return "HUF";
case IDR: return "IDR";
case ILS: return "ILS";
case IMP: return "IMP";
case INR: return "INR";
case IQD: return "IQD";
case IRR: return "IRR";
case ISK: return "ISK";
case JEP: return "JEP";
case JMD: return "JMD";
case JOD: return "JOD";
case JPY: return "JPY";
case KES: return "KES";
case KGS: return "KGS";
case KHR: return "KHR";
case KMF: return "KMF";
case KPW: return "KPW";
case KRW: return "KRW";
case KWD: return "KWD";
case KYD: return "KYD";
case KZT: return "KZT";
case LAK: return "LAK";
case LBP: return "LBP";
case LKR: return "LKR";
case LRD: return "LRD";
case LSL: return "LSL";
case LYD: return "LYD";
case MAD: return "MAD";
case MDL: return "MDL";
case MGA: return "MGA";
case MKD: return "MKD";
case MMK: return "MMK";
case MNT: return "MNT";
case MOP: return "MOP";
case MRU: return "MRU";
case MUR: return "MUR";
case MVR: return "MVR";
case MWK: return "MWK";
case MXN: return "MXN";
case MXV: return "MXV";
case MYR: return "MYR";
case MZN: return "MZN";
case NAD: return "NAD";
case NGN: return "NGN";
case NIO: return "NIO";
case NOK: return "NOK";
case NPR: return "NPR";
case NZD: return "NZD";
case OMR: return "OMR";
case PAB: return "PAB";
case PEN: return "PEN";
case PGK: return "PGK";
case PHP: return "PHP";
case PKR: return "PKR";
case PLN: return "PLN";
case PYG: return "PYG";
case QAR: return "QAR";
case RON: return "RON";
case RSD: return "RSD";
case RUB: return "RUB";
case RWF: return "RWF";
case SAR: return "SAR";
case SBD: return "SBD";
case SCR: return "SCR";
case SDG: return "SDG";
case SEK: return "SEK";
case SGD: return "SGD";
case SHP: return "SHP";
case SLL: return "SLL";
case SOS: return "SOS";
case SRD: return "SRD";
case SSP: return "SSP";
case STN: return "STN";
case SVC: return "SVC";
case SYP: return "SYP";
case SZL: return "SZL";
case THB: return "THB";
case TJS: return "TJS";
case TMT: return "TMT";
case TND: return "TND";
case TOP: return "TOP";
case TRY: return "TRY";
case TTD: return "TTD";
case TVD: return "TVD";
case TWD: return "TWD";
case TZS: return "TZS";
case UAH: return "UAH";
case UGX: return "UGX";
case USD: return "USD";
case USN: return "USN";
case UYI: return "UYI";
case UYU: return "UYU";
case UZS: return "UZS";
case VEF: return "VEF";
case VND: return "VND";
case VUV: return "VUV";
case WST: return "WST";
case XAF: return "XAF";
case XAG: return "XAG";
case XAU: return "XAU";
case XBA: return "XBA";
case XBB: return "XBB";
case XBC: return "XBC";
case XBD: return "XBD";
case XCD: return "XCD";
case XDR: return "XDR";
case XOF: return "XOF";
case XPD: return "XPD";
case XPF: return "XPF";
case XPT: return "XPT";
case XSU: return "XSU";
case XTS: return "XTS";
case XUA: return "XUA";
case XXX: return "XXX";
case YER: return "YER";
case ZAR: return "ZAR";
case ZMW: return "ZMW";
case ZWL: return "ZWL";
case NULL: return null;
default: return "?";
}
}
public String getSystem() {
switch (this) {
case AED: return "urn:iso:std:iso:4217";
case AFN: return "urn:iso:std:iso:4217";
case ALL: return "urn:iso:std:iso:4217";
case AMD: return "urn:iso:std:iso:4217";
case ANG: return "urn:iso:std:iso:4217";
case AOA: return "urn:iso:std:iso:4217";
case ARS: return "urn:iso:std:iso:4217";
case AUD: return "urn:iso:std:iso:4217";
case AWG: return "urn:iso:std:iso:4217";
case AZN: return "urn:iso:std:iso:4217";
case BAM: return "urn:iso:std:iso:4217";
case BBD: return "urn:iso:std:iso:4217";
case BDT: return "urn:iso:std:iso:4217";
case BGN: return "urn:iso:std:iso:4217";
case BHD: return "urn:iso:std:iso:4217";
case BIF: return "urn:iso:std:iso:4217";
case BMD: return "urn:iso:std:iso:4217";
case BND: return "urn:iso:std:iso:4217";
case BOB: return "urn:iso:std:iso:4217";
case BOV: return "urn:iso:std:iso:4217";
case BRL: return "urn:iso:std:iso:4217";
case BSD: return "urn:iso:std:iso:4217";
case BTN: return "urn:iso:std:iso:4217";
case BWP: return "urn:iso:std:iso:4217";
case BYN: return "urn:iso:std:iso:4217";
case BZD: return "urn:iso:std:iso:4217";
case CAD: return "urn:iso:std:iso:4217";
case CDF: return "urn:iso:std:iso:4217";
case CHE: return "urn:iso:std:iso:4217";
case CHF: return "urn:iso:std:iso:4217";
case CHW: return "urn:iso:std:iso:4217";
case CLF: return "urn:iso:std:iso:4217";
case CLP: return "urn:iso:std:iso:4217";
case CNY: return "urn:iso:std:iso:4217";
case COP: return "urn:iso:std:iso:4217";
case COU: return "urn:iso:std:iso:4217";
case CRC: return "urn:iso:std:iso:4217";
case CUC: return "urn:iso:std:iso:4217";
case CUP: return "urn:iso:std:iso:4217";
case CVE: return "urn:iso:std:iso:4217";
case CZK: return "urn:iso:std:iso:4217";
case DJF: return "urn:iso:std:iso:4217";
case DKK: return "urn:iso:std:iso:4217";
case DOP: return "urn:iso:std:iso:4217";
case DZD: return "urn:iso:std:iso:4217";
case EGP: return "urn:iso:std:iso:4217";
case ERN: return "urn:iso:std:iso:4217";
case ETB: return "urn:iso:std:iso:4217";
case EUR: return "urn:iso:std:iso:4217";
case FJD: return "urn:iso:std:iso:4217";
case FKP: return "urn:iso:std:iso:4217";
case GBP: return "urn:iso:std:iso:4217";
case GEL: return "urn:iso:std:iso:4217";
case GGP: return "urn:iso:std:iso:4217";
case GHS: return "urn:iso:std:iso:4217";
case GIP: return "urn:iso:std:iso:4217";
case GMD: return "urn:iso:std:iso:4217";
case GNF: return "urn:iso:std:iso:4217";
case GTQ: return "urn:iso:std:iso:4217";
case GYD: return "urn:iso:std:iso:4217";
case HKD: return "urn:iso:std:iso:4217";
case HNL: return "urn:iso:std:iso:4217";
case HRK: return "urn:iso:std:iso:4217";
case HTG: return "urn:iso:std:iso:4217";
case HUF: return "urn:iso:std:iso:4217";
case IDR: return "urn:iso:std:iso:4217";
case ILS: return "urn:iso:std:iso:4217";
case IMP: return "urn:iso:std:iso:4217";
case INR: return "urn:iso:std:iso:4217";
case IQD: return "urn:iso:std:iso:4217";
case IRR: return "urn:iso:std:iso:4217";
case ISK: return "urn:iso:std:iso:4217";
case JEP: return "urn:iso:std:iso:4217";
case JMD: return "urn:iso:std:iso:4217";
case JOD: return "urn:iso:std:iso:4217";
case JPY: return "urn:iso:std:iso:4217";
case KES: return "urn:iso:std:iso:4217";
case KGS: return "urn:iso:std:iso:4217";
case KHR: return "urn:iso:std:iso:4217";
case KMF: return "urn:iso:std:iso:4217";
case KPW: return "urn:iso:std:iso:4217";
case KRW: return "urn:iso:std:iso:4217";
case KWD: return "urn:iso:std:iso:4217";
case KYD: return "urn:iso:std:iso:4217";
case KZT: return "urn:iso:std:iso:4217";
case LAK: return "urn:iso:std:iso:4217";
case LBP: return "urn:iso:std:iso:4217";
case LKR: return "urn:iso:std:iso:4217";
case LRD: return "urn:iso:std:iso:4217";
case LSL: return "urn:iso:std:iso:4217";
case LYD: return "urn:iso:std:iso:4217";
case MAD: return "urn:iso:std:iso:4217";
case MDL: return "urn:iso:std:iso:4217";
case MGA: return "urn:iso:std:iso:4217";
case MKD: return "urn:iso:std:iso:4217";
case MMK: return "urn:iso:std:iso:4217";
case MNT: return "urn:iso:std:iso:4217";
case MOP: return "urn:iso:std:iso:4217";
case MRU: return "urn:iso:std:iso:4217";
case MUR: return "urn:iso:std:iso:4217";
case MVR: return "urn:iso:std:iso:4217";
case MWK: return "urn:iso:std:iso:4217";
case MXN: return "urn:iso:std:iso:4217";
case MXV: return "urn:iso:std:iso:4217";
case MYR: return "urn:iso:std:iso:4217";
case MZN: return "urn:iso:std:iso:4217";
case NAD: return "urn:iso:std:iso:4217";
case NGN: return "urn:iso:std:iso:4217";
case NIO: return "urn:iso:std:iso:4217";
case NOK: return "urn:iso:std:iso:4217";
case NPR: return "urn:iso:std:iso:4217";
case NZD: return "urn:iso:std:iso:4217";
case OMR: return "urn:iso:std:iso:4217";
case PAB: return "urn:iso:std:iso:4217";
case PEN: return "urn:iso:std:iso:4217";
case PGK: return "urn:iso:std:iso:4217";
case PHP: return "urn:iso:std:iso:4217";
case PKR: return "urn:iso:std:iso:4217";
case PLN: return "urn:iso:std:iso:4217";
case PYG: return "urn:iso:std:iso:4217";
case QAR: return "urn:iso:std:iso:4217";
case RON: return "urn:iso:std:iso:4217";
case RSD: return "urn:iso:std:iso:4217";
case RUB: return "urn:iso:std:iso:4217";
case RWF: return "urn:iso:std:iso:4217";
case SAR: return "urn:iso:std:iso:4217";
case SBD: return "urn:iso:std:iso:4217";
case SCR: return "urn:iso:std:iso:4217";
case SDG: return "urn:iso:std:iso:4217";
case SEK: return "urn:iso:std:iso:4217";
case SGD: return "urn:iso:std:iso:4217";
case SHP: return "urn:iso:std:iso:4217";
case SLL: return "urn:iso:std:iso:4217";
case SOS: return "urn:iso:std:iso:4217";
case SRD: return "urn:iso:std:iso:4217";
case SSP: return "urn:iso:std:iso:4217";
case STN: return "urn:iso:std:iso:4217";
case SVC: return "urn:iso:std:iso:4217";
case SYP: return "urn:iso:std:iso:4217";
case SZL: return "urn:iso:std:iso:4217";
case THB: return "urn:iso:std:iso:4217";
case TJS: return "urn:iso:std:iso:4217";
case TMT: return "urn:iso:std:iso:4217";
case TND: return "urn:iso:std:iso:4217";
case TOP: return "urn:iso:std:iso:4217";
case TRY: return "urn:iso:std:iso:4217";
case TTD: return "urn:iso:std:iso:4217";
case TVD: return "urn:iso:std:iso:4217";
case TWD: return "urn:iso:std:iso:4217";
case TZS: return "urn:iso:std:iso:4217";
case UAH: return "urn:iso:std:iso:4217";
case UGX: return "urn:iso:std:iso:4217";
case USD: return "urn:iso:std:iso:4217";
case USN: return "urn:iso:std:iso:4217";
case UYI: return "urn:iso:std:iso:4217";
case UYU: return "urn:iso:std:iso:4217";
case UZS: return "urn:iso:std:iso:4217";
case VEF: return "urn:iso:std:iso:4217";
case VND: return "urn:iso:std:iso:4217";
case VUV: return "urn:iso:std:iso:4217";
case WST: return "urn:iso:std:iso:4217";
case XAF: return "urn:iso:std:iso:4217";
case XAG: return "urn:iso:std:iso:4217";
case XAU: return "urn:iso:std:iso:4217";
case XBA: return "urn:iso:std:iso:4217";
case XBB: return "urn:iso:std:iso:4217";
case XBC: return "urn:iso:std:iso:4217";
case XBD: return "urn:iso:std:iso:4217";
case XCD: return "urn:iso:std:iso:4217";
case XDR: return "urn:iso:std:iso:4217";
case XOF: return "urn:iso:std:iso:4217";
case XPD: return "urn:iso:std:iso:4217";
case XPF: return "urn:iso:std:iso:4217";
case XPT: return "urn:iso:std:iso:4217";
case XSU: return "urn:iso:std:iso:4217";
case XTS: return "urn:iso:std:iso:4217";
case XUA: return "urn:iso:std:iso:4217";
case XXX: return "urn:iso:std:iso:4217";
case YER: return "urn:iso:std:iso:4217";
case ZAR: return "urn:iso:std:iso:4217";
case ZMW: return "urn:iso:std:iso:4217";
case ZWL: return "urn:iso:std:iso:4217";
case NULL: return null;
default: return "?";
}
}
public String getDefinition() {
switch (this) {
case AED: return "";
case AFN: return "";
case ALL: return "";
case AMD: return "";
case ANG: return "";
case AOA: return "";
case ARS: return "";
case AUD: return "";
case AWG: return "";
case AZN: return "";
case BAM: return "";
case BBD: return "";
case BDT: return "";
case BGN: return "";
case BHD: return "";
case BIF: return "";
case BMD: return "";
case BND: return "";
case BOB: return "";
case BOV: return "";
case BRL: return "";
case BSD: return "";
case BTN: return "";
case BWP: return "";
case BYN: return "";
case BZD: return "";
case CAD: return "";
case CDF: return "";
case CHE: return "";
case CHF: return "";
case CHW: return "";
case CLF: return "";
case CLP: return "";
case CNY: return "";
case COP: return "";
case COU: return "";
case CRC: return "";
case CUC: return "";
case CUP: return "";
case CVE: return "";
case CZK: return "";
case DJF: return "";
case DKK: return "";
case DOP: return "";
case DZD: return "";
case EGP: return "";
case ERN: return "";
case ETB: return "";
case EUR: return "";
case FJD: return "";
case FKP: return "";
case GBP: return "";
case GEL: return "";
case GGP: return "";
case GHS: return "";
case GIP: return "";
case GMD: return "";
case GNF: return "";
case GTQ: return "";
case GYD: return "";
case HKD: return "";
case HNL: return "";
case HRK: return "";
case HTG: return "";
case HUF: return "";
case IDR: return "";
case ILS: return "";
case IMP: return "";
case INR: return "";
case IQD: return "";
case IRR: return "";
case ISK: return "";
case JEP: return "";
case JMD: return "";
case JOD: return "";
case JPY: return "";
case KES: return "";
case KGS: return "";
case KHR: return "";
case KMF: return "";
case KPW: return "";
case KRW: return "";
case KWD: return "";
case KYD: return "";
case KZT: return "";
case LAK: return "";
case LBP: return "";
case LKR: return "";
case LRD: return "";
case LSL: return "";
case LYD: return "";
case MAD: return "";
case MDL: return "";
case MGA: return "";
case MKD: return "";
case MMK: return "";
case MNT: return "";
case MOP: return "";
case MRU: return "";
case MUR: return "";
case MVR: return "";
case MWK: return "";
case MXN: return "";
case MXV: return "";
case MYR: return "";
case MZN: return "";
case NAD: return "";
case NGN: return "";
case NIO: return "";
case NOK: return "";
case NPR: return "";
case NZD: return "";
case OMR: return "";
case PAB: return "";
case PEN: return "";
case PGK: return "";
case PHP: return "";
case PKR: return "";
case PLN: return "";
case PYG: return "";
case QAR: return "";
case RON: return "";
case RSD: return "";
case RUB: return "";
case RWF: return "";
case SAR: return "";
case SBD: return "";
case SCR: return "";
case SDG: return "";
case SEK: return "";
case SGD: return "";
case SHP: return "";
case SLL: return "";
case SOS: return "";
case SRD: return "";
case SSP: return "";
case STN: return "";
case SVC: return "";
case SYP: return "";
case SZL: return "";
case THB: return "";
case TJS: return "";
case TMT: return "";
case TND: return "";
case TOP: return "";
case TRY: return "";
case TTD: return "";
case TVD: return "";
case TWD: return "";
case TZS: return "";
case UAH: return "";
case UGX: return "";
case USD: return "";
case USN: return "";
case UYI: return "";
case UYU: return "";
case UZS: return "";
case VEF: return "";
case VND: return "";
case VUV: return "";
case WST: return "";
case XAF: return "";
case XAG: return "";
case XAU: return "";
case XBA: return "";
case XBB: return "";
case XBC: return "";
case XBD: return "";
case XCD: return "";
case XDR: return "";
case XOF: return "";
case XPD: return "";
case XPF: return "";
case XPT: return "";
case XSU: return "";
case XTS: return "";
case XUA: return "";
case XXX: return "";
case YER: return "";
case ZAR: return "";
case ZMW: return "";
case ZWL: return "";
case NULL: return null;
default: return "?";
}
}
public String getDisplay() {
switch (this) {
case AED: return "United Arab Emirates dirham";
case AFN: return "Afghan afghani";
case ALL: return "Albanian lek";
case AMD: return "Armenian dram";
case ANG: return "Netherlands Antillean guilder";
case AOA: return "Angolan kwanza";
case ARS: return "Argentine peso";
case AUD: return "Australian dollar";
case AWG: return "Aruban florin";
case AZN: return "Azerbaijani manat";
case BAM: return "Bosnia and Herzegovina convertible mark";
case BBD: return "Barbados dollar";
case BDT: return "Bangladeshi taka";
case BGN: return "Bulgarian lev";
case BHD: return "Bahraini dinar";
case BIF: return "Burundian franc";
case BMD: return "Bermudian dollar";
case BND: return "Brunei dollar";
case BOB: return "Boliviano";
case BOV: return "Bolivian Mvdol (funds code)";
case BRL: return "Brazilian real";
case BSD: return "Bahamian dollar";
case BTN: return "Bhutanese ngultrum";
case BWP: return "Botswana pula";
case BYN: return "Belarusian ruble";
case BZD: return "Belize dollar";
case CAD: return "Canadian dollar";
case CDF: return "Congolese franc";
case CHE: return "WIR Euro (complementary currency)";
case CHF: return "Swiss franc";
case CHW: return "WIR Franc (complementary currency)";
case CLF: return "Unidad de Fomento (funds code)";
case CLP: return "Chilean peso";
case CNY: return "Renminbi (Chinese) yuan[8]";
case COP: return "Colombian peso";
case COU: return "Unidad de Valor Real (UVR) (funds code)[9]";
case CRC: return "Costa Rican colon";
case CUC: return "Cuban convertible peso";
case CUP: return "Cuban peso";
case CVE: return "Cape Verde escudo";
case CZK: return "Czech koruna";
case DJF: return "Djiboutian franc";
case DKK: return "Danish krone";
case DOP: return "Dominican peso";
case DZD: return "Algerian dinar";
case EGP: return "Egyptian pound";
case ERN: return "Eritrean nakfa";
case ETB: return "Ethiopian birr";
case EUR: return "Euro";
case FJD: return "Fiji dollar";
case FKP: return "Falkland Islands pound";
case GBP: return "Pound sterling";
case GEL: return "Georgian lari";
case GGP: return "Guernsey Pound";
case GHS: return "Ghanaian cedi";
case GIP: return "Gibraltar pound";
case GMD: return "Gambian dalasi";
case GNF: return "Guinean franc";
case GTQ: return "Guatemalan quetzal";
case GYD: return "Guyanese dollar";
case HKD: return "Hong Kong dollar";
case HNL: return "Honduran lempira";
case HRK: return "Croatian kuna";
case HTG: return "Haitian gourde";
case HUF: return "Hungarian forint";
case IDR: return "Indonesian rupiah";
case ILS: return "Israeli new shekel";
case IMP: return "Isle of Man Pound";
case INR: return "Indian rupee";
case IQD: return "Iraqi dinar";
case IRR: return "Iranian rial";
case ISK: return "Icelandic króna";
case JEP: return "Jersey Pound";
case JMD: return "Jamaican dollar";
case JOD: return "Jordanian dinar";
case JPY: return "Japanese yen";
case KES: return "Kenyan shilling";
case KGS: return "Kyrgyzstani som";
case KHR: return "Cambodian riel";
case KMF: return "Comoro franc";
case KPW: return "North Korean won";
case KRW: return "South Korean won";
case KWD: return "Kuwaiti dinar";
case KYD: return "Cayman Islands dollar";
case KZT: return "Kazakhstani tenge";
case LAK: return "Lao kip";
case LBP: return "Lebanese pound";
case LKR: return "Sri Lankan rupee";
case LRD: return "Liberian dollar";
case LSL: return "Lesotho loti";
case LYD: return "Libyan dinar";
case MAD: return "Moroccan dirham";
case MDL: return "Moldovan leu";
case MGA: return "Malagasy ariary";
case MKD: return "Macedonian denar";
case MMK: return "Myanmar kyat";
case MNT: return "Mongolian tögrög";
case MOP: return "Macanese pataca";
case MRU: return "Mauritanian ouguiya";
case MUR: return "Mauritian rupee";
case MVR: return "Maldivian rufiyaa";
case MWK: return "Malawian kwacha";
case MXN: return "Mexican peso";
case MXV: return "Mexican Unidad de Inversion (UDI) (funds code)";
case MYR: return "Malaysian ringgit";
case MZN: return "Mozambican metical";
case NAD: return "Namibian dollar";
case NGN: return "Nigerian naira";
case NIO: return "Nicaraguan córdoba";
case NOK: return "Norwegian krone";
case NPR: return "Nepalese rupee";
case NZD: return "New Zealand dollar";
case OMR: return "Omani rial";
case PAB: return "Panamanian balboa";
case PEN: return "Peruvian Sol";
case PGK: return "Papua New Guinean kina";
case PHP: return "Philippine piso[13]";
case PKR: return "Pakistani rupee";
case PLN: return "Polish złoty";
case PYG: return "Paraguayan guaraní";
case QAR: return "Qatari riyal";
case RON: return "Romanian leu";
case RSD: return "Serbian dinar";
case RUB: return "Russian ruble";
case RWF: return "Rwandan franc";
case SAR: return "Saudi riyal";
case SBD: return "Solomon Islands dollar";
case SCR: return "Seychelles rupee";
case SDG: return "Sudanese pound";
case SEK: return "Swedish krona/kronor";
case SGD: return "Singapore dollar";
case SHP: return "Saint Helena pound";
case SLL: return "Sierra Leonean leone";
case SOS: return "Somali shilling";
case SRD: return "Surinamese dollar";
case SSP: return "South Sudanese pound";
case STN: return "São Tomé and Príncipe dobra";
case SVC: return "Salvadoran colón";
case SYP: return "Syrian pound";
case SZL: return "Swazi lilangeni";
case THB: return "Thai baht";
case TJS: return "Tajikistani somoni";
case TMT: return "Turkmenistan manat";
case TND: return "Tunisian dinar";
case TOP: return "Tongan paʻanga";
case TRY: return "Turkish lira";
case TTD: return "Trinidad and Tobago dollar";
case TVD: return "Tuvalu Dollar";
case TWD: return "New Taiwan dollar";
case TZS: return "Tanzanian shilling";
case UAH: return "Ukrainian hryvnia";
case UGX: return "Ugandan shilling";
case USD: return "United States dollar";
case USN: return "United States dollar (next day) (funds code)";
case UYI: return "Uruguay Peso en Unidades Indexadas (URUIURUI) (funds code)";
case UYU: return "Uruguayan peso";
case UZS: return "Uzbekistan som";
case VEF: return "Venezuelan bolívar";
case VND: return "Vietnamese đồng";
case VUV: return "Vanuatu vatu";
case WST: return "Samoan tala";
case XAF: return "CFA franc BEAC";
case XAG: return "Silver (one troy ounce)";
case XAU: return "Gold (one troy ounce)";
case XBA: return "European Composite Unit (EURCO) (bond market unit)";
case XBB: return "European Monetary Unit (E.M.U.-6) (bond market unit)";
case XBC: return "European Unit of Account 9 (E.U.A.-9) (bond market unit)";
case XBD: return "European Unit of Account 17 (E.U.A.-17) (bond market unit)";
case XCD: return "East Caribbean dollar";
case XDR: return "Special drawing rights";
case XOF: return "CFA franc BCEAO";
case XPD: return "Palladium (one troy ounce)";
case XPF: return "CFP franc (franc Pacifique)";
case XPT: return "Platinum (one troy ounce)";
case XSU: return "SUCRE";
case XTS: return "Code reserved for testing purposes";
case XUA: return "ADB Unit of Account";
case XXX: return "No currency";
case YER: return "Yemeni rial";
case ZAR: return "South African rand";
case ZMW: return "Zambian kwacha";
case ZWL: return "Zimbabwean dollar A/10";
case NULL: return null;
default: return "?";
}
}
}
public static class CurrenciesEnumFactory implements EnumFactory
