/// <summary>
        /// Parse MedicationDispenseDispenseComponent
        /// </summary>
        public static Hl7.Fhir.Model.MedicationDispense.MedicationDispenseDispenseComponent ParseMedicationDispenseDispenseComponent(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.MedicationDispense.MedicationDispenseDispenseComponent existingInstance = null)
        {
            Hl7.Fhir.Model.MedicationDispense.MedicationDispenseDispenseComponent result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.MedicationDispense.MedicationDispenseDispenseComponent();
            string currentElementName = reader.CurrentElementName;

            reader.EnterElement();

            while (reader.HasMoreElements())
            {
                var atName = reader.CurrentElementName;
                // Parse element extension
                if (atName == "extension")
                {
                    result.Extension = new List <Hl7.Fhir.Model.Extension>();
                    reader.EnterArray();

                    while (ParserUtils.IsAtArrayElement(reader, "extension"))
                    {
                        result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
                    }

                    reader.LeaveArray();
                }

                // Parse element _id
                else if (atName == "_id")
                {
                    result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
                }

                // Parse element identifier
                else if (atName == "identifier")
                {
                    result.Identifier = IdentifierParser.ParseIdentifier(reader, errors);
                }

                // Parse element status
                else if (atName == "status")
                {
                    result.StatusElement = CodeParser.ParseCode <Hl7.Fhir.Model.MedicationDispense.MedicationDispenseStatus>(reader, errors);
                }

                // Parse element type
                else if (atName == "type")
                {
                    result.Type = CodeableConceptParser.ParseCodeableConcept(reader, errors);
                }

                // Parse element quantity
                else if (atName == "quantity")
                {
                    result.Quantity = QuantityParser.ParseQuantity(reader, errors);
                }

                // Parse element medication
                else if (atName == "medication")
                {
                    result.Medication = ResourceReferenceParser.ParseResourceReference(reader, errors);
                }

                // Parse element whenPrepared
                else if (atName == "whenPrepared")
                {
                    result.WhenPrepared = PeriodParser.ParsePeriod(reader, errors);
                }

                // Parse element whenHandedOver
                else if (atName == "whenHandedOver")
                {
                    result.WhenHandedOver = PeriodParser.ParsePeriod(reader, errors);
                }

                // Parse element destination
                else if (atName == "destination")
                {
                    result.Destination = ResourceReferenceParser.ParseResourceReference(reader, errors);
                }

                // Parse element receiver
                else if (atName == "receiver")
                {
                    result.Receiver = new List <Hl7.Fhir.Model.ResourceReference>();
                    reader.EnterArray();

                    while (ParserUtils.IsAtArrayElement(reader, "receiver"))
                    {
                        result.Receiver.Add(ResourceReferenceParser.ParseResourceReference(reader, errors));
                    }

                    reader.LeaveArray();
                }

                // Parse element dosage
                else if (atName == "dosage")
                {
                    result.Dosage = new List <Hl7.Fhir.Model.MedicationDispense.MedicationDispenseDispenseDosageComponent>();
                    reader.EnterArray();

                    while (ParserUtils.IsAtArrayElement(reader, "dosage"))
                    {
                        result.Dosage.Add(MedicationDispenseParser.ParseMedicationDispenseDispenseDosageComponent(reader, errors));
                    }

                    reader.LeaveArray();
                }

                else
                {
                    errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
                    reader.SkipSubElementsFor(currentElementName);
                    result = null;
                }
            }

            reader.LeaveElement();
            return(result);
        }
        /// <summary>
        /// Parse MedicationDispense
        /// </summary>
        public static Hl7.Fhir.Model.MedicationDispense ParseMedicationDispense(IFhirReader reader, ErrorList errors, Hl7.Fhir.Model.MedicationDispense existingInstance = null)
        {
            Hl7.Fhir.Model.MedicationDispense result = existingInstance != null ? existingInstance : new Hl7.Fhir.Model.MedicationDispense();
            string currentElementName = reader.CurrentElementName;

            reader.EnterElement();

            while (reader.HasMoreElements())
            {
                var atName = reader.CurrentElementName;
                // Parse element extension
                if (atName == "extension")
                {
                    result.Extension = new List <Hl7.Fhir.Model.Extension>();
                    reader.EnterArray();

                    while (ParserUtils.IsAtArrayElement(reader, "extension"))
                    {
                        result.Extension.Add(ExtensionParser.ParseExtension(reader, errors));
                    }

                    reader.LeaveArray();
                }

                // Parse element language
                else if (atName == "language")
                {
                    result.LanguageElement = CodeParser.ParseCode(reader, errors);
                }

                // Parse element text
                else if (atName == "text")
                {
                    result.Text = NarrativeParser.ParseNarrative(reader, errors);
                }

                // Parse element contained
                else if (atName == "contained")
                {
                    result.Contained = new List <Hl7.Fhir.Model.Resource>();
                    reader.EnterArray();

                    while (ParserUtils.IsAtArrayElement(reader, "contained"))
                    {
                        result.Contained.Add(ParserUtils.ParseContainedResource(reader, errors));
                    }

                    reader.LeaveArray();
                }

                // Parse element _id
                else if (atName == "_id")
                {
                    result.LocalIdElement = Id.Parse(reader.ReadPrimitiveContents(typeof(Id)));
                }

                // Parse element identifier
                else if (atName == "identifier")
                {
                    result.Identifier = IdentifierParser.ParseIdentifier(reader, errors);
                }

                // Parse element status
                else if (atName == "status")
                {
                    result.StatusElement = CodeParser.ParseCode <Hl7.Fhir.Model.MedicationDispense.MedicationDispenseStatus>(reader, errors);
                }

                // Parse element patient
                else if (atName == "patient")
                {
                    result.Patient = ResourceReferenceParser.ParseResourceReference(reader, errors);
                }

                // Parse element dispenser
                else if (atName == "dispenser")
                {
                    result.Dispenser = ResourceReferenceParser.ParseResourceReference(reader, errors);
                }

                // Parse element authorizingPrescription
                else if (atName == "authorizingPrescription")
                {
                    result.AuthorizingPrescription = new List <Hl7.Fhir.Model.ResourceReference>();
                    reader.EnterArray();

                    while (ParserUtils.IsAtArrayElement(reader, "authorizingPrescription"))
                    {
                        result.AuthorizingPrescription.Add(ResourceReferenceParser.ParseResourceReference(reader, errors));
                    }

                    reader.LeaveArray();
                }

                // Parse element dispense
                else if (atName == "dispense")
                {
                    result.Dispense = new List <Hl7.Fhir.Model.MedicationDispense.MedicationDispenseDispenseComponent>();
                    reader.EnterArray();

                    while (ParserUtils.IsAtArrayElement(reader, "dispense"))
                    {
                        result.Dispense.Add(MedicationDispenseParser.ParseMedicationDispenseDispenseComponent(reader, errors));
                    }

                    reader.LeaveArray();
                }

                // Parse element substitution
                else if (atName == "substitution")
                {
                    result.Substitution = MedicationDispenseParser.ParseMedicationDispenseSubstitutionComponent(reader, errors);
                }

                else
                {
                    errors.Add(String.Format("Encountered unknown element {0} while parsing {1}", reader.CurrentElementName, currentElementName), reader);
                    reader.SkipSubElementsFor(currentElementName);
                    result = null;
                }
            }

            reader.LeaveElement();
            return(result);
        }
        internal static Resource ParseResource(IFhirReader reader, ErrorList errors)
        {
            try
            {
                reader.MoveToContent();

                if (ParserUtils.IsAtFhirElement(reader, "AdverseReaction"))
                {
                    return(AdverseReactionParser.ParseAdverseReaction(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Alert"))
                {
                    return(AlertParser.ParseAlert(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "AllergyIntolerance"))
                {
                    return(AllergyIntoleranceParser.ParseAllergyIntolerance(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "CarePlan"))
                {
                    return(CarePlanParser.ParseCarePlan(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Condition"))
                {
                    return(ConditionParser.ParseCondition(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Conformance"))
                {
                    return(ConformanceParser.ParseConformance(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Coverage"))
                {
                    return(CoverageParser.ParseCoverage(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Device"))
                {
                    return(DeviceParser.ParseDevice(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "DeviceCapabilities"))
                {
                    return(DeviceCapabilitiesParser.ParseDeviceCapabilities(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "DeviceLog"))
                {
                    return(DeviceLogParser.ParseDeviceLog(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "DeviceObservation"))
                {
                    return(DeviceObservationParser.ParseDeviceObservation(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "DiagnosticOrder"))
                {
                    return(DiagnosticOrderParser.ParseDiagnosticOrder(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "DiagnosticReport"))
                {
                    return(DiagnosticReportParser.ParseDiagnosticReport(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Document"))
                {
                    return(DocumentParser.ParseDocument(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "DocumentReference"))
                {
                    return(DocumentReferenceParser.ParseDocumentReference(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Encounter"))
                {
                    return(EncounterParser.ParseEncounter(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "FamilyHistory"))
                {
                    return(FamilyHistoryParser.ParseFamilyHistory(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Group"))
                {
                    return(GroupParser.ParseGroup(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "ImagingStudy"))
                {
                    return(ImagingStudyParser.ParseImagingStudy(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Immunization"))
                {
                    return(ImmunizationParser.ParseImmunization(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "ImmunizationProfile"))
                {
                    return(ImmunizationProfileParser.ParseImmunizationProfile(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "List"))
                {
                    return(ListParser.ParseList(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Location"))
                {
                    return(LocationParser.ParseLocation(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Media"))
                {
                    return(MediaParser.ParseMedia(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Medication"))
                {
                    return(MedicationParser.ParseMedication(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "MedicationAdministration"))
                {
                    return(MedicationAdministrationParser.ParseMedicationAdministration(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "MedicationDispense"))
                {
                    return(MedicationDispenseParser.ParseMedicationDispense(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "MedicationPrescription"))
                {
                    return(MedicationPrescriptionParser.ParseMedicationPrescription(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "MedicationStatement"))
                {
                    return(MedicationStatementParser.ParseMedicationStatement(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Message"))
                {
                    return(MessageParser.ParseMessage(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Observation"))
                {
                    return(ObservationParser.ParseObservation(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "OperationOutcome"))
                {
                    return(OperationOutcomeParser.ParseOperationOutcome(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Order"))
                {
                    return(OrderParser.ParseOrder(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "OrderResponse"))
                {
                    return(OrderResponseParser.ParseOrderResponse(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Organization"))
                {
                    return(OrganizationParser.ParseOrganization(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Other"))
                {
                    return(OtherParser.ParseOther(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Patient"))
                {
                    return(PatientParser.ParsePatient(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Practitioner"))
                {
                    return(PractitionerParser.ParsePractitioner(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Procedure"))
                {
                    return(ProcedureParser.ParseProcedure(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Profile"))
                {
                    return(ProfileParser.ParseProfile(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Provenance"))
                {
                    return(ProvenanceParser.ParseProvenance(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Query"))
                {
                    return(QueryParser.ParseQuery(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Questionnaire"))
                {
                    return(QuestionnaireParser.ParseQuestionnaire(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "RelatedPerson"))
                {
                    return(RelatedPersonParser.ParseRelatedPerson(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "SecurityEvent"))
                {
                    return(SecurityEventParser.ParseSecurityEvent(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Specimen"))
                {
                    return(SpecimenParser.ParseSpecimen(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Substance"))
                {
                    return(SubstanceParser.ParseSubstance(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Supply"))
                {
                    return(SupplyParser.ParseSupply(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "ValueSet"))
                {
                    return(ValueSetParser.ParseValueSet(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Binary"))
                {
                    return(BinaryParser.ParseBinary(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "Appointment"))
                {
                    return(AppointmentParser.ParseAppointment(reader, errors));
                }
                else if (ParserUtils.IsAtFhirElement(reader, "InterestOfCare"))
                {
                    return(InterestOfCareParser.ParseInterestOfCare(reader, errors));
                }
                else
                {
                    errors.Add(String.Format("Encountered unrecognized resource '{0}'", reader.CurrentElementName), reader);
                    reader.SkipSubElementsFor(reader.CurrentElementName);
                    return(null);
                }
            }
            catch (Exception xe)
            {
                errors.Add(xe.Message, reader);
                return(null);
            }
        }