text: // Copyright (c) 2005-2014 Code Synthesis Tools CC
  //
  // This program was generated by CodeSynthesis XSD, an XML Schema to
  // C++ data binding compiler.
  //
  // This program is free software; you can redistribute it and/or modify
  // it under the terms of the GNU General Public License version 2 as
  // published by the Free Software Foundation.
  //
  // This program is distributed in the hope that it will be useful,
  // but WITHOUT ANY WARRANTY; without even the implied warranty of
  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  // GNU General Public License for more details.
  //
  // You should have received a copy of the GNU General Public License
  // along with this program; if not, write to the Free Software
  // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  //
  // In addition, as a special exception, Code Synthesis Tools CC gives
  // permission to link this program with the Xerces-C++ library (or with
  // modified versions of Xerces-C++ that use the same license as Xerces-C++),
  // and distribute linked combinations including the two. You must obey
  // the GNU General Public License version 2 in all respects for all of
  // the code used other than Xerces-C++. If you modify this copy of the
  // program, you may extend this exception to your version of the program,
  // but you are not obligated to do so. If you do not wish to do so, delete
  // this exception statement from your version.
  //
  // Furthermore, Code Synthesis Tools CC makes a special exception for
  // the Free/Libre and Open Source Software (FLOSS) which is described
  // in the accompanying FLOSSE file.
  //
  
  // Begin prologue.
  //
  //
  // End prologue.
  
  #include <xsd/cxx/pre.hxx>
  
  #include "Substance.hxx"
  
  namespace mil
  {
    namespace tatrc
    {
      namespace physiology
      {
        namespace datamodel
        {
          // enumSubstanceState
          // 
  
          enumSubstanceState::
          enumSubstanceState ()
          : ::xml_schema::string ()
          {
          }
  
          enumSubstanceState::
          enumSubstanceState (value v)
          : ::xml_schema::string (_xsd_enumSubstanceState_literals_[v])
          {
          }
  
          enumSubstanceState::
          enumSubstanceState (const char* v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceState::
          enumSubstanceState (const ::std::string& v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceState::
          enumSubstanceState (const ::xml_schema::string& v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceState::
          enumSubstanceState (const enumSubstanceState& v,
                              ::xml_schema::flags f,
                              ::xml_schema::container* c)
          : ::xml_schema::string (v, f, c)
          {
          }
  
          enumSubstanceState& enumSubstanceState::
          operator= (value v)
          {
            static_cast< ::xml_schema::string& > (*this) = 
            ::xml_schema::string (_xsd_enumSubstanceState_literals_[v]);
  
            return *this;
          }
  
  
          // enumSubstanceIonicState
          // 
  
          enumSubstanceIonicState::
          enumSubstanceIonicState ()
          : ::xml_schema::string ()
          {
          }
  
          enumSubstanceIonicState::
          enumSubstanceIonicState (value v)
          : ::xml_schema::string (_xsd_enumSubstanceIonicState_literals_[v])
          {
          }
  
          enumSubstanceIonicState::
          enumSubstanceIonicState (const char* v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceIonicState::
          enumSubstanceIonicState (const ::std::string& v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceIonicState::
          enumSubstanceIonicState (const ::xml_schema::string& v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceIonicState::
          enumSubstanceIonicState (const enumSubstanceIonicState& v,
                                   ::xml_schema::flags f,
                                   ::xml_schema::container* c)
          : ::xml_schema::string (v, f, c)
          {
          }
  
          enumSubstanceIonicState& enumSubstanceIonicState::
          operator= (value v)
          {
            static_cast< ::xml_schema::string& > (*this) = 
            ::xml_schema::string (_xsd_enumSubstanceIonicState_literals_[v]);
  
            return *this;
          }
  
  
          // enumSubstanceBindingProtein
          // 
  
          enumSubstanceBindingProtein::
          enumSubstanceBindingProtein ()
          : ::xml_schema::string ()
          {
          }
  
          enumSubstanceBindingProtein::
          enumSubstanceBindingProtein (value v)
          : ::xml_schema::string (_xsd_enumSubstanceBindingProtein_literals_[v])
          {
          }
  
          enumSubstanceBindingProtein::
          enumSubstanceBindingProtein (const char* v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceBindingProtein::
          enumSubstanceBindingProtein (const ::std::string& v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceBindingProtein::
          enumSubstanceBindingProtein (const ::xml_schema::string& v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceBindingProtein::
          enumSubstanceBindingProtein (const enumSubstanceBindingProtein& v,
                                       ::xml_schema::flags f,
                                       ::xml_schema::container* c)
          : ::xml_schema::string (v, f, c)
          {
          }
  
          enumSubstanceBindingProtein& enumSubstanceBindingProtein::
          operator= (value v)
          {
            static_cast< ::xml_schema::string& > (*this) = 
            ::xml_schema::string (_xsd_enumSubstanceBindingProtein_literals_[v]);
  
            return *this;
          }
  
  
          // enumCharge
          // 
  
          enumCharge::
          enumCharge ()
          : ::xml_schema::string ()
          {
          }
  
          enumCharge::
          enumCharge (value v)
          : ::xml_schema::string (_xsd_enumCharge_literals_[v])
          {
          }
  
          enumCharge::
          enumCharge (const char* v)
          : ::xml_schema::string (v)
          {
          }
  
          enumCharge::
          enumCharge (const ::std::string& v)
          : ::xml_schema::string (v)
          {
          }
  
          enumCharge::
          enumCharge (const ::xml_schema::string& v)
          : ::xml_schema::string (v)
          {
          }
  
          enumCharge::
          enumCharge (const enumCharge& v,
                      ::xml_schema::flags f,
                      ::xml_schema::container* c)
          : ::xml_schema::string (v, f, c)
          {
          }
  
          enumCharge& enumCharge::
          operator= (value v)
          {
            static_cast< ::xml_schema::string& > (*this) = 
            ::xml_schema::string (_xsd_enumCharge_literals_[v]);
  
            return *this;
          }
  
  
          // enumSubstanceClass
          // 
  
          enumSubstanceClass::
          enumSubstanceClass ()
          : ::xml_schema::string ()
          {
          }
  
          enumSubstanceClass::
          enumSubstanceClass (value v)
          : ::xml_schema::string (_xsd_enumSubstanceClass_literals_[v])
          {
          }
  
          enumSubstanceClass::
          enumSubstanceClass (const char* v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceClass::
          enumSubstanceClass (const ::std::string& v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceClass::
          enumSubstanceClass (const ::xml_schema::string& v)
          : ::xml_schema::string (v)
          {
          }
  
          enumSubstanceClass::
          enumSubstanceClass (const enumSubstanceClass& v,
                              ::xml_schema::flags f,
                              ::xml_schema::container* c)
          : ::xml_schema::string (v, f, c)
          {
          }
  
          enumSubstanceClass& enumSubstanceClass::
          operator= (value v)
          {
            static_cast< ::xml_schema::string& > (*this) = 
            ::xml_schema::string (_xsd_enumSubstanceClass_literals_[v]);
  
            return *this;
          }
  
  
          // SubstanceAerosolizationData
          // 
  
          const SubstanceAerosolizationData::BronchioleModifier_type& SubstanceAerosolizationData::
          BronchioleModifier () const
          {
            return this->BronchioleModifier_.get ();
          }
  
          SubstanceAerosolizationData::BronchioleModifier_type& SubstanceAerosolizationData::
          BronchioleModifier ()
          {
            return this->BronchioleModifier_.get ();
          }
  
          void SubstanceAerosolizationData::
          BronchioleModifier (const BronchioleModifier_type& x)
          {
            this->BronchioleModifier_.set (x);
          }
  
          void SubstanceAerosolizationData::
          BronchioleModifier (::std::unique_ptr< BronchioleModifier_type > x)
          {
            this->BronchioleModifier_.set (std::move (x));
          }
  
          const SubstanceAerosolizationData::InflammationCoefficient_type& SubstanceAerosolizationData::
          InflammationCoefficient () const
          {
            return this->InflammationCoefficient_.get ();
          }
  
          SubstanceAerosolizationData::InflammationCoefficient_type& SubstanceAerosolizationData::
          InflammationCoefficient ()
          {
            return this->InflammationCoefficient_.get ();
          }
  
          void SubstanceAerosolizationData::
          InflammationCoefficient (const InflammationCoefficient_type& x)
          {
            this->InflammationCoefficient_.set (x);
          }
  
          void SubstanceAerosolizationData::
          InflammationCoefficient (::std::unique_ptr< InflammationCoefficient_type > x)
          {
            this->InflammationCoefficient_.set (std::move (x));
          }
  
          const SubstanceAerosolizationData::ParticulateSizeDistribution_type& SubstanceAerosolizationData::
          ParticulateSizeDistribution () const
          {
            return this->ParticulateSizeDistribution_.get ();
          }
  
          SubstanceAerosolizationData::ParticulateSizeDistribution_type& SubstanceAerosolizationData::
          ParticulateSizeDistribution ()
          {
            return this->ParticulateSizeDistribution_.get ();
          }
  
          void SubstanceAerosolizationData::
          ParticulateSizeDistribution (const ParticulateSizeDistribution_type& x)
          {
            this->ParticulateSizeDistribution_.set (x);
          }
  
          void SubstanceAerosolizationData::
          ParticulateSizeDistribution (::std::unique_ptr< ParticulateSizeDistribution_type > x)
          {
            this->ParticulateSizeDistribution_.set (std::move (x));
          }
  
  
          // SubstancePharmacokineticsData
          // 
  
          const SubstancePharmacokineticsData::Physicochemicals_optional& SubstancePharmacokineticsData::
          Physicochemicals () const
          {
            return this->Physicochemicals_;
          }
  
          SubstancePharmacokineticsData::Physicochemicals_optional& SubstancePharmacokineticsData::
          Physicochemicals ()
          {
            return this->Physicochemicals_;
          }
  
          void SubstancePharmacokineticsData::
          Physicochemicals (const Physicochemicals_type& x)
          {
            this->Physicochemicals_.set (x);
          }
  
          void SubstancePharmacokineticsData::
          Physicochemicals (const Physicochemicals_optional& x)
          {
            this->Physicochemicals_ = x;
          }
  
          void SubstancePharmacokineticsData::
          Physicochemicals (::std::unique_ptr< Physicochemicals_type > x)
          {
            this->Physicochemicals_.set (std::move (x));
          }
  
          const SubstancePharmacokineticsData::TissueKinetics_sequence& SubstancePharmacokineticsData::
          TissueKinetics () const
          {
            return this->TissueKinetics_;
          }
  
          SubstancePharmacokineticsData::TissueKinetics_sequence& SubstancePharmacokineticsData::
          TissueKinetics ()
          {
            return this->TissueKinetics_;
          }
  
          void SubstancePharmacokineticsData::
          TissueKinetics (const TissueKinetics_sequence& s)
          {
            this->TissueKinetics_ = s;
          }
  
  
          // SubstancePhysicochemicalData
          // 
  
          const SubstancePhysicochemicalData::AcidDissociationConstant_sequence& SubstancePhysicochemicalData::
          AcidDissociationConstant () const
          {
            return this->AcidDissociationConstant_;
          }
  
          SubstancePhysicochemicalData::AcidDissociationConstant_sequence& SubstancePhysicochemicalData::
          AcidDissociationConstant ()
          {
            return this->AcidDissociationConstant_;
          }
  
          void SubstancePhysicochemicalData::
          AcidDissociationConstant (const AcidDissociationConstant_sequence& s)
          {
            this->AcidDissociationConstant_ = s;
          }
  
          const SubstancePhysicochemicalData::BindingProtein_type& SubstancePhysicochemicalData::
          BindingProtein () const
          {
            return this->BindingProtein_.get ();
          }
  
          SubstancePhysicochemicalData::BindingProtein_type& SubstancePhysicochemicalData::
          BindingProtein ()
          {
            return this->BindingProtein_.get ();
          }
  
          void SubstancePhysicochemicalData::
          BindingProtein (const BindingProtein_type& x)
          {
            this->BindingProtein_.set (x);
          }
  
          void SubstancePhysicochemicalData::
          BindingProtein (::std::unique_ptr< BindingProtein_type > x)
          {
            this->BindingProtein_.set (std::move (x));
          }
  
          const SubstancePhysicochemicalData::BloodPlasmaRatio_type& SubstancePhysicochemicalData::
          BloodPlasmaRatio () const
          {
            return this->BloodPlasmaRatio_.get ();
          }
  
          SubstancePhysicochemicalData::BloodPlasmaRatio_type& SubstancePhysicochemicalData::
          BloodPlasmaRatio ()
          {
            return this->BloodPlasmaRatio_.get ();
          }
  
          void SubstancePhysicochemicalData::
          BloodPlasmaRatio (const BloodPlasmaRatio_type& x)
          {
            this->BloodPlasmaRatio_.set (x);
          }
  
          void SubstancePhysicochemicalData::
          BloodPlasmaRatio (::std::unique_ptr< BloodPlasmaRatio_type > x)
          {
            this->BloodPlasmaRatio_.set (std::move (x));
          }
  
          const SubstancePhysicochemicalData::FractionUnboundInPlasma_type& SubstancePhysicochemicalData::
          FractionUnboundInPlasma () const
          {
            return this->FractionUnboundInPlasma_.get ();
          }
  
          SubstancePhysicochemicalData::FractionUnboundInPlasma_type& SubstancePhysicochemicalData::
          FractionUnboundInPlasma ()
          {
            return this->FractionUnboundInPlasma_.get ();
          }
  
          void SubstancePhysicochemicalData::
          FractionUnboundInPlasma (const FractionUnboundInPlasma_type& x)
          {
            this->FractionUnboundInPlasma_.set (x);
          }
  
          void SubstancePhysicochemicalData::
          FractionUnboundInPlasma (::std::unique_ptr< FractionUnboundInPlasma_type > x)
          {
            this->FractionUnboundInPlasma_.set (std::move (x));
          }
  
          const SubstancePhysicochemicalData::IonicState_type& SubstancePhysicochemicalData::
          IonicState () const
          {
            return this->IonicState_.get ();
          }
  
          SubstancePhysicochemicalData::IonicState_type& SubstancePhysicochemicalData::
          IonicState ()
          {
            return this->IonicState_.get ();
          }
  
          void SubstancePhysicochemicalData::
          IonicState (const IonicState_type& x)
          {
            this->IonicState_.set (x);
          }
  
          void SubstancePhysicochemicalData::
          IonicState (::std::unique_ptr< IonicState_type > x)
          {
            this->IonicState_.set (std::move (x));
          }
  
          const SubstancePhysicochemicalData::LogP_type& SubstancePhysicochemicalData::
          LogP () const
          {
            return this->LogP_.get ();
          }
  
          SubstancePhysicochemicalData::LogP_type& SubstancePhysicochemicalData::
          LogP ()
          {
            return this->LogP_.get ();
          }
  
          void SubstancePhysicochemicalData::
          LogP (const LogP_type& x)
          {
            this->LogP_.set (x);
          }
  
          void SubstancePhysicochemicalData::
          LogP (::std::unique_ptr< LogP_type > x)
          {
            this->LogP_.set (std::move (x));
          }
  
          const SubstancePhysicochemicalData::HydrogenBondCount_optional& SubstancePhysicochemicalData::
          HydrogenBondCount () const
          {
            return this->HydrogenBondCount_;
          }
  
          SubstancePhysicochemicalData::HydrogenBondCount_optional& SubstancePhysicochemicalData::
          HydrogenBondCount ()
          {
            return this->HydrogenBondCount_;
          }
  
          void SubstancePhysicochemicalData::
          HydrogenBondCount (const HydrogenBondCount_type& x)
          {
            this->HydrogenBondCount_.set (x);
          }
  
          void SubstancePhysicochemicalData::
          HydrogenBondCount (const HydrogenBondCount_optional& x)
          {
            this->HydrogenBondCount_ = x;
          }
  
          void SubstancePhysicochemicalData::
          HydrogenBondCount (::std::unique_ptr< HydrogenBondCount_type > x)
          {
            this->HydrogenBondCount_.set (std::move (x));
          }
  
          const SubstancePhysicochemicalData::PolarSurfaceArea_optional& SubstancePhysicochemicalData::
          PolarSurfaceArea () const
          {
            return this->PolarSurfaceArea_;
          }
  
          SubstancePhysicochemicalData::PolarSurfaceArea_optional& SubstancePhysicochemicalData::
          PolarSurfaceArea ()
          {
            return this->PolarSurfaceArea_;
          }
  
          void SubstancePhysicochemicalData::
          PolarSurfaceArea (const PolarSurfaceArea_type& x)
          {
            this->PolarSurfaceArea_.set (x);
          }
  
          void SubstancePhysicochemicalData::
          PolarSurfaceArea (const PolarSurfaceArea_optional& x)
          {
            this->PolarSurfaceArea_ = x;
          }
  
          void SubstancePhysicochemicalData::
          PolarSurfaceArea (::std::unique_ptr< PolarSurfaceArea_type > x)
          {
            this->PolarSurfaceArea_.set (std::move (x));
          }
  
  
          // SubstanceTissuePharmacokineticsData
          // 
  
          const SubstanceTissuePharmacokineticsData::Name_type& SubstanceTissuePharmacokineticsData::
          Name () const
          {
            return this->Name_.get ();
          }
  
          SubstanceTissuePharmacokineticsData::Name_type& SubstanceTissuePharmacokineticsData::
          Name ()
          {
            return this->Name_.get ();
          }
  
          void SubstanceTissuePharmacokineticsData::
          Name (const Name_type& x)
          {
            this->Name_.set (x);
          }
  
          void SubstanceTissuePharmacokineticsData::
          Name (::std::unique_ptr< Name_type > x)
          {
            this->Name_.set (std::move (x));
          }
  
          const SubstanceTissuePharmacokineticsData::PartitionCoefficient_optional& SubstanceTissuePharmacokineticsData::
          PartitionCoefficient () const
          {
            return this->PartitionCoefficient_;
          }
  
          SubstanceTissuePharmacokineticsData::PartitionCoefficient_optional& SubstanceTissuePharmacokineticsData::
          PartitionCoefficient ()
          {
            return this->PartitionCoefficient_;
          }
  
          void SubstanceTissuePharmacokineticsData::
          PartitionCoefficient (const PartitionCoefficient_type& x)
          {
            this->PartitionCoefficient_.set (x);
          }
  
          void SubstanceTissuePharmacokineticsData::
          PartitionCoefficient (const PartitionCoefficient_optional& x)
          {
            this->PartitionCoefficient_ = x;
          }
  
          void SubstanceTissuePharmacokineticsData::
          PartitionCoefficient (::std::unique_ptr< PartitionCoefficient_type > x)
          {
            this->PartitionCoefficient_.set (std::move (x));
          }
  
  
          // SubstancePharmacodynamicsData
          // 
  
          const SubstancePharmacodynamicsData::EffectSiteRateConstant_type& SubstancePharmacodynamicsData::
          EffectSiteRateConstant () const
          {
            return this->EffectSiteRateConstant_.get ();
          }
  
          SubstancePharmacodynamicsData::EffectSiteRateConstant_type& SubstancePharmacodynamicsData::
          EffectSiteRateConstant ()
          {
            return this->EffectSiteRateConstant_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          EffectSiteRateConstant (const EffectSiteRateConstant_type& x)
          {
            this->EffectSiteRateConstant_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          EffectSiteRateConstant (::std::unique_ptr< EffectSiteRateConstant_type > x)
          {
            this->EffectSiteRateConstant_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::EMaxShapeParameter_type& SubstancePharmacodynamicsData::
          EMaxShapeParameter () const
          {
            return this->EMaxShapeParameter_.get ();
          }
  
          SubstancePharmacodynamicsData::EMaxShapeParameter_type& SubstancePharmacodynamicsData::
          EMaxShapeParameter ()
          {
            return this->EMaxShapeParameter_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          EMaxShapeParameter (const EMaxShapeParameter_type& x)
          {
            this->EMaxShapeParameter_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          EMaxShapeParameter (::std::unique_ptr< EMaxShapeParameter_type > x)
          {
            this->EMaxShapeParameter_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::AntibacterialEffect_type& SubstancePharmacodynamicsData::
          AntibacterialEffect () const
          {
            return this->AntibacterialEffect_.get ();
          }
  
          SubstancePharmacodynamicsData::AntibacterialEffect_type& SubstancePharmacodynamicsData::
          AntibacterialEffect ()
          {
            return this->AntibacterialEffect_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          AntibacterialEffect (const AntibacterialEffect_type& x)
          {
            this->AntibacterialEffect_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          AntibacterialEffect (::std::unique_ptr< AntibacterialEffect_type > x)
          {
            this->AntibacterialEffect_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::Bronchodilation_type& SubstancePharmacodynamicsData::
          Bronchodilation () const
          {
            return this->Bronchodilation_.get ();
          }
  
          SubstancePharmacodynamicsData::Bronchodilation_type& SubstancePharmacodynamicsData::
          Bronchodilation ()
          {
            return this->Bronchodilation_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          Bronchodilation (const Bronchodilation_type& x)
          {
            this->Bronchodilation_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          Bronchodilation (::std::unique_ptr< Bronchodilation_type > x)
          {
            this->Bronchodilation_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::CentralNervousModifier_type& SubstancePharmacodynamicsData::
          CentralNervousModifier () const
          {
            return this->CentralNervousModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::CentralNervousModifier_type& SubstancePharmacodynamicsData::
          CentralNervousModifier ()
          {
            return this->CentralNervousModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          CentralNervousModifier (const CentralNervousModifier_type& x)
          {
            this->CentralNervousModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          CentralNervousModifier (::std::unique_ptr< CentralNervousModifier_type > x)
          {
            this->CentralNervousModifier_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::DiastolicPressureModifier_type& SubstancePharmacodynamicsData::
          DiastolicPressureModifier () const
          {
            return this->DiastolicPressureModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::DiastolicPressureModifier_type& SubstancePharmacodynamicsData::
          DiastolicPressureModifier ()
          {
            return this->DiastolicPressureModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          DiastolicPressureModifier (const DiastolicPressureModifier_type& x)
          {
            this->DiastolicPressureModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          DiastolicPressureModifier (::std::unique_ptr< DiastolicPressureModifier_type > x)
          {
            this->DiastolicPressureModifier_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::FeverModifier_type& SubstancePharmacodynamicsData::
          FeverModifier () const
          {
            return this->FeverModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::FeverModifier_type& SubstancePharmacodynamicsData::
          FeverModifier ()
          {
            return this->FeverModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          FeverModifier (const FeverModifier_type& x)
          {
            this->FeverModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          FeverModifier (::std::unique_ptr< FeverModifier_type > x)
          {
            this->FeverModifier_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::HeartRateModifier_type& SubstancePharmacodynamicsData::
          HeartRateModifier () const
          {
            return this->HeartRateModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::HeartRateModifier_type& SubstancePharmacodynamicsData::
          HeartRateModifier ()
          {
            return this->HeartRateModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          HeartRateModifier (const HeartRateModifier_type& x)
          {
            this->HeartRateModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          HeartRateModifier (::std::unique_ptr< HeartRateModifier_type > x)
          {
            this->HeartRateModifier_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::HemorrhageModifier_type& SubstancePharmacodynamicsData::
          HemorrhageModifier () const
          {
            return this->HemorrhageModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::HemorrhageModifier_type& SubstancePharmacodynamicsData::
          HemorrhageModifier ()
          {
            return this->HemorrhageModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          HemorrhageModifier (const HemorrhageModifier_type& x)
          {
            this->HemorrhageModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          HemorrhageModifier (::std::unique_ptr< HemorrhageModifier_type > x)
          {
            this->HemorrhageModifier_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::NeuromuscularBlock_type& SubstancePharmacodynamicsData::
          NeuromuscularBlock () const
          {
            return this->NeuromuscularBlock_.get ();
          }
  
          SubstancePharmacodynamicsData::NeuromuscularBlock_type& SubstancePharmacodynamicsData::
          NeuromuscularBlock ()
          {
            return this->NeuromuscularBlock_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          NeuromuscularBlock (const NeuromuscularBlock_type& x)
          {
            this->NeuromuscularBlock_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          NeuromuscularBlock (::std::unique_ptr< NeuromuscularBlock_type > x)
          {
            this->NeuromuscularBlock_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::PainModifier_type& SubstancePharmacodynamicsData::
          PainModifier () const
          {
            return this->PainModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::PainModifier_type& SubstancePharmacodynamicsData::
          PainModifier ()
          {
            return this->PainModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          PainModifier (const PainModifier_type& x)
          {
            this->PainModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          PainModifier (::std::unique_ptr< PainModifier_type > x)
          {
            this->PainModifier_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::PupilReactivityModifier_type& SubstancePharmacodynamicsData::
          PupilReactivityModifier () const
          {
            return this->PupilReactivityModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::PupilReactivityModifier_type& SubstancePharmacodynamicsData::
          PupilReactivityModifier ()
          {
            return this->PupilReactivityModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          PupilReactivityModifier (const PupilReactivityModifier_type& x)
          {
            this->PupilReactivityModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          PupilReactivityModifier (::std::unique_ptr< PupilReactivityModifier_type > x)
          {
            this->PupilReactivityModifier_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::PupilSizeModifier_type& SubstancePharmacodynamicsData::
          PupilSizeModifier () const
          {
            return this->PupilSizeModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::PupilSizeModifier_type& SubstancePharmacodynamicsData::
          PupilSizeModifier ()
          {
            return this->PupilSizeModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          PupilSizeModifier (const PupilSizeModifier_type& x)
          {
            this->PupilSizeModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          PupilSizeModifier (::std::unique_ptr< PupilSizeModifier_type > x)
          {
            this->PupilSizeModifier_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::RespirationRateModifier_type& SubstancePharmacodynamicsData::
          RespirationRateModifier () const
          {
            return this->RespirationRateModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::RespirationRateModifier_type& SubstancePharmacodynamicsData::
          RespirationRateModifier ()
          {
            return this->RespirationRateModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          RespirationRateModifier (const RespirationRateModifier_type& x)
          {
            this->RespirationRateModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          RespirationRateModifier (::std::unique_ptr< RespirationRateModifier_type > x)
          {
            this->RespirationRateModifier_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::Sedation_type& SubstancePharmacodynamicsData::
          Sedation () const
          {
            return this->Sedation_.get ();
          }
  
          SubstancePharmacodynamicsData::Sedation_type& SubstancePharmacodynamicsData::
          Sedation ()
          {
            return this->Sedation_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          Sedation (const Sedation_type& x)
          {
            this->Sedation_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          Sedation (::std::unique_ptr< Sedation_type > x)
          {
            this->Sedation_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::SystolicPressureModifier_type& SubstancePharmacodynamicsData::
          SystolicPressureModifier () const
          {
            return this->SystolicPressureModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::SystolicPressureModifier_type& SubstancePharmacodynamicsData::
          SystolicPressureModifier ()
          {
            return this->SystolicPressureModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          SystolicPressureModifier (const SystolicPressureModifier_type& x)
          {
            this->SystolicPressureModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          SystolicPressureModifier (::std::unique_ptr< SystolicPressureModifier_type > x)
          {
            this->SystolicPressureModifier_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::TidalVolumeModifier_type& SubstancePharmacodynamicsData::
          TidalVolumeModifier () const
          {
            return this->TidalVolumeModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::TidalVolumeModifier_type& SubstancePharmacodynamicsData::
          TidalVolumeModifier ()
          {
            return this->TidalVolumeModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          TidalVolumeModifier (const TidalVolumeModifier_type& x)
          {
            this->TidalVolumeModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          TidalVolumeModifier (::std::unique_ptr< TidalVolumeModifier_type > x)
          {
            this->TidalVolumeModifier_.set (std::move (x));
          }
  
          const SubstancePharmacodynamicsData::TubularPermeabilityModifier_type& SubstancePharmacodynamicsData::
          TubularPermeabilityModifier () const
          {
            return this->TubularPermeabilityModifier_.get ();
          }
  
          SubstancePharmacodynamicsData::TubularPermeabilityModifier_type& SubstancePharmacodynamicsData::
          TubularPermeabilityModifier ()
          {
            return this->TubularPermeabilityModifier_.get ();
          }
  
          void SubstancePharmacodynamicsData::
          TubularPermeabilityModifier (const TubularPermeabilityModifier_type& x)
          {
            this->TubularPermeabilityModifier_.set (x);
          }
  
          void SubstancePharmacodynamicsData::
          TubularPermeabilityModifier (::std::unique_ptr< TubularPermeabilityModifier_type > x)
          {
            this->TubularPermeabilityModifier_.set (std::move (x));
          }
  
  
          // SubstanceClearanceData
          // 
  
          const SubstanceClearanceData::Systemic_optional& SubstanceClearanceData::
          Systemic () const
          {
            return this->Systemic_;
          }
  
          SubstanceClearanceData::Systemic_optional& SubstanceClearanceData::
          Systemic ()
          {
            return this->Systemic_;
          }
  
          void SubstanceClearanceData::
          Systemic (const Systemic_type& x)
          {
            this->Systemic_.set (x);
          }
  
          void SubstanceClearanceData::
          Systemic (const Systemic_optional& x)
          {
            this->Systemic_ = x;
          }
  
          void SubstanceClearanceData::
          Systemic (::std::unique_ptr< Systemic_type > x)
          {
            this->Systemic_.set (std::move (x));
          }
  
          const SubstanceClearanceData::RenalDynamics_optional& SubstanceClearanceData::
          RenalDynamics () const
          {
            return this->RenalDynamics_;
          }
  
          SubstanceClearanceData::RenalDynamics_optional& SubstanceClearanceData::
          RenalDynamics ()
          {
            return this->RenalDynamics_;
          }
  
          void SubstanceClearanceData::
          RenalDynamics (const RenalDynamics_type& x)
          {
            this->RenalDynamics_.set (x);
          }
  
          void SubstanceClearanceData::
          RenalDynamics (const RenalDynamics_optional& x)
          {
            this->RenalDynamics_ = x;
          }
  
          void SubstanceClearanceData::
          RenalDynamics (::std::unique_ptr< RenalDynamics_type > x)
          {
            this->RenalDynamics_.set (std::move (x));
          }
  
          const SubstanceClearanceData::CellRegulation_optional& SubstanceClearanceData::
          CellRegulation () const
          {
            return this->CellRegulation_;
          }
  
          SubstanceClearanceData::CellRegulation_optional& SubstanceClearanceData::
          CellRegulation ()
          {
            return this->CellRegulation_;
          }
  
          void SubstanceClearanceData::
          CellRegulation (const CellRegulation_type& x)
          {
            this->CellRegulation_.set (x);
          }
  
          void SubstanceClearanceData::
          CellRegulation (const CellRegulation_optional& x)
          {
            this->CellRegulation_ = x;
          }
  
          void SubstanceClearanceData::
          CellRegulation (::std::unique_ptr< CellRegulation_type > x)
          {
            this->CellRegulation_.set (std::move (x));
          }
  
  
          // SubstanceData
          // 
  
          const SubstanceData::Name_type& SubstanceData::
          Name () const
          {
            return this->Name_.get ();
          }
  
          SubstanceData::Name_type& SubstanceData::
          Name ()
          {
            return this->Name_.get ();
          }
  
          void SubstanceData::
          Name (const Name_type& x)
          {
            this->Name_.set (x);
          }
  
          void SubstanceData::
          Name (::std::unique_ptr< Name_type > x)
          {
            this->Name_.set (std::move (x));
          }
  
          const SubstanceData::Classification_optional& SubstanceData::
          Classification () const
          {
            return this->Classification_;
          }
  
          SubstanceData::Classification_optional& SubstanceData::
          Classification ()
          {
            return this->Classification_;
          }
  
          void SubstanceData::
          Classification (const Classification_type& x)
          {
            this->Classification_.set (x);
          }
  
          void SubstanceData::
          Classification (const Classification_optional& x)
          {
            this->Classification_ = x;
          }
  
          void SubstanceData::
          Classification (::std::unique_ptr< Classification_type > x)
          {
            this->Classification_.set (std::move (x));
          }
  
          const SubstanceData::Density_optional& SubstanceData::
          Density () const
          {
            return this->Density_;
          }
  
          SubstanceData::Density_optional& SubstanceData::
          Density ()
          {
            return this->Density_;
          }
  
          void SubstanceData::
          Density (const Density_type& x)
          {
            this->Density_.set (x);
          }
  
          void SubstanceData::
          Density (const Density_optional& x)
          {
            this->Density_ = x;
          }
  
          void SubstanceData::
          Density (::std::unique_ptr< Density_type > x)
          {
            this->Density_.set (std::move (x));
          }
  
          const SubstanceData::MolarMass_optional& SubstanceData::
          MolarMass () const
          {
            return this->MolarMass_;
          }
  
          SubstanceData::MolarMass_optional& SubstanceData::
          MolarMass ()
          {
            return this->MolarMass_;
          }
  
          void SubstanceData::
          MolarMass (const MolarMass_type& x)
          {
            this->MolarMass_.set (x);
          }
  
          void SubstanceData::
          MolarMass (const MolarMass_optional& x)
          {
            this->MolarMass_ = x;
          }
  
          void SubstanceData::
          MolarMass (::std::unique_ptr< MolarMass_type > x)
          {
            this->MolarMass_.set (std::move (x));
          }
  
          const SubstanceData::State_optional& SubstanceData::
          State () const
          {
            return this->State_;
          }
  
          SubstanceData::State_optional& SubstanceData::
          State ()
          {
            return this->State_;
          }
  
          void SubstanceData::
          State (const State_type& x)
          {
            this->State_.set (x);
          }
  
          void SubstanceData::
          State (const State_optional& x)
          {
            this->State_ = x;
          }
  
          void SubstanceData::
          State (::std::unique_ptr< State_type > x)
          {
            this->State_.set (std::move (x));
          }
  
          const SubstanceData::MaximumDiffusionFlux_optional& SubstanceData::
          MaximumDiffusionFlux () const
          {
            return this->MaximumDiffusionFlux_;
          }
  
          SubstanceData::MaximumDiffusionFlux_optional& SubstanceData::
          MaximumDiffusionFlux ()
          {
            return this->MaximumDiffusionFlux_;
          }
  
          void SubstanceData::
          MaximumDiffusionFlux (const MaximumDiffusionFlux_type& x)
          {
            this->MaximumDiffusionFlux_.set (x);
          }
  
          void SubstanceData::
          MaximumDiffusionFlux (const MaximumDiffusionFlux_optional& x)
          {
            this->MaximumDiffusionFlux_ = x;
          }
  
          void SubstanceData::
          MaximumDiffusionFlux (::std::unique_ptr< MaximumDiffusionFlux_type > x)
          {
            this->MaximumDiffusionFlux_.set (std::move (x));
          }
  
          const SubstanceData::MichaelisCoefficient_optional& SubstanceData::
          MichaelisCoefficient () const
          {
            return this->MichaelisCoefficient_;
          }
  
          SubstanceData::MichaelisCoefficient_optional& SubstanceData::
          MichaelisCoefficient ()
          {
            return this->MichaelisCoefficient_;
          }
  
          void SubstanceData::
          MichaelisCoefficient (const MichaelisCoefficient_type& x)
          {
            this->MichaelisCoefficient_.set (x);
          }
  
          void SubstanceData::
          MichaelisCoefficient (const MichaelisCoefficient_optional& x)
          {
            this->MichaelisCoefficient_ = x;
          }
  
          void SubstanceData::
          MichaelisCoefficient (::std::unique_ptr< MichaelisCoefficient_type > x)
          {
            this->MichaelisCoefficient_.set (std::move (x));
          }
  
          const SubstanceData::MembraneResistance_optional& SubstanceData::
          MembraneResistance () const
          {
            return this->MembraneResistance_;
          }
  
          SubstanceData::MembraneResistance_optional& SubstanceData::
          MembraneResistance ()
          {
            return this->MembraneResistance_;
          }
  
          void SubstanceData::
          MembraneResistance (const MembraneResistance_type& x)
          {
            this->MembraneResistance_.set (x);
          }
  
          void SubstanceData::
          MembraneResistance (const MembraneResistance_optional& x)
          {
            this->MembraneResistance_ = x;
          }
  
          void SubstanceData::
          MembraneResistance (::std::unique_ptr< MembraneResistance_type > x)
          {
            this->MembraneResistance_.set (std::move (x));
          }
  
          const SubstanceData::Aerosolization_optional& SubstanceData::
          Aerosolization () const
          {
            return this->Aerosolization_;
          }
  
          SubstanceData::Aerosolization_optional& SubstanceData::
          Aerosolization ()
          {
            return this->Aerosolization_;
          }
  
          void SubstanceData::
          Aerosolization (const Aerosolization_type& x)
          {
            this->Aerosolization_.set (x);
          }
  
          void SubstanceData::
          Aerosolization (const Aerosolization_optional& x)
          {
            this->Aerosolization_ = x;
          }
  
          void SubstanceData::
          Aerosolization (::std::unique_ptr< Aerosolization_type > x)
          {
            this->Aerosolization_.set (std::move (x));
          }
  
          const SubstanceData::AreaUnderCurve_optional& SubstanceData::
          AreaUnderCurve () const
          {
            return this->AreaUnderCurve_;
          }
  
          SubstanceData::AreaUnderCurve_optional& SubstanceData::
          AreaUnderCurve ()
          {
            return this->AreaUnderCurve_;
          }
  
          void SubstanceData::
          AreaUnderCurve (const AreaUnderCurve_type& x)
          {
            this->AreaUnderCurve_.set (x);
          }
  
          void SubstanceData::
          AreaUnderCurve (const AreaUnderCurve_optional& x)
          {
            this->AreaUnderCurve_ = x;
          }
  
          void SubstanceData::
          AreaUnderCurve (::std::unique_ptr< AreaUnderCurve_type > x)
          {
            this->AreaUnderCurve_.set (std::move (x));
          }
  
          const SubstanceData::BloodConcentration_optional& SubstanceData::
          BloodConcentration () const
          {
            return this->BloodConcentration_;
          }
  
          SubstanceData::BloodConcentration_optional& SubstanceData::
          BloodConcentration ()
          {
            return this->BloodConcentration_;
          }
  
          void SubstanceData::
          BloodConcentration (const BloodConcentration_type& x)
          {
            this->BloodConcentration_.set (x);
          }
  
          void SubstanceData::
          BloodConcentration (const BloodConcentration_optional& x)
          {
            this->BloodConcentration_ = x;
          }
  
          void SubstanceData::
          BloodConcentration (::std::unique_ptr< BloodConcentration_type > x)
          {
            this->BloodConcentration_.set (std::move (x));
          }
  
          const SubstanceData::EffectSiteConcentration_optional& SubstanceData::
          EffectSiteConcentration () const
          {
            return this->EffectSiteConcentration_;
          }
  
          SubstanceData::EffectSiteConcentration_optional& SubstanceData::
          EffectSiteConcentration ()
          {
            return this->EffectSiteConcentration_;
          }
  
          void SubstanceData::
          EffectSiteConcentration (const EffectSiteConcentration_type& x)
          {
            this->EffectSiteConcentration_.set (x);
          }
  
          void SubstanceData::
          EffectSiteConcentration (const EffectSiteConcentration_optional& x)
          {
            this->EffectSiteConcentration_ = x;
          }
  
          void SubstanceData::
          EffectSiteConcentration (::std::unique_ptr< EffectSiteConcentration_type > x)
          {
            this->EffectSiteConcentration_.set (std::move (x));
          }
  
          const SubstanceData::MassInBody_optional& SubstanceData::
          MassInBody () const
          {
            return this->MassInBody_;
          }
  
          SubstanceData::MassInBody_optional& SubstanceData::
          MassInBody ()
          {
            return this->MassInBody_;
          }
  
          void SubstanceData::
          MassInBody (const MassInBody_type& x)
          {
            this->MassInBody_.set (x);
          }
  
          void SubstanceData::
          MassInBody (const MassInBody_optional& x)
          {
            this->MassInBody_ = x;
          }
  
          void SubstanceData::
          MassInBody (::std::unique_ptr< MassInBody_type > x)
          {
            this->MassInBody_.set (std::move (x));
          }
  
          const SubstanceData::MassInBlood_optional& SubstanceData::
          MassInBlood () const
          {
            return this->MassInBlood_;
          }
  
          SubstanceData::MassInBlood_optional& SubstanceData::
          MassInBlood ()
          {
            return this->MassInBlood_;
          }
  
          void SubstanceData::
          MassInBlood (const MassInBlood_type& x)
          {
            this->MassInBlood_.set (x);
          }
  
          void SubstanceData::
          MassInBlood (const MassInBlood_optional& x)
          {
            this->MassInBlood_ = x;
          }
  
          void SubstanceData::
          MassInBlood (::std::unique_ptr< MassInBlood_type > x)
          {
            this->MassInBlood_.set (std::move (x));
          }
  
          const SubstanceData::MassInTissue_optional& SubstanceData::
          MassInTissue () const
          {
            return this->MassInTissue_;
          }
  
          SubstanceData::MassInTissue_optional& SubstanceData::
          MassInTissue ()
          {
            return this->MassInTissue_;
          }
  
          void SubstanceData::
          MassInTissue (const MassInTissue_type& x)
          {
            this->MassInTissue_.set (x);
          }
  
          void SubstanceData::
          MassInTissue (const MassInTissue_optional& x)
          {
            this->MassInTissue_ = x;
          }
  
          void SubstanceData::
          MassInTissue (::std::unique_ptr< MassInTissue_type > x)
          {
            this->MassInTissue_.set (std::move (x));
          }
  
          const SubstanceData::PlasmaConcentration_optional& SubstanceData::
          PlasmaConcentration () const
          {
            return this->PlasmaConcentration_;
          }
  
          SubstanceData::PlasmaConcentration_optional& SubstanceData::
          PlasmaConcentration ()
          {
            return this->PlasmaConcentration_;
          }
  
          void SubstanceData::
          PlasmaConcentration (const PlasmaConcentration_type& x)
          {
            this->PlasmaConcentration_.set (x);
          }
  
          void SubstanceData::
          PlasmaConcentration (const PlasmaConcentration_optional& x)
          {
            this->PlasmaConcentration_ = x;
          }
  
          void SubstanceData::
          PlasmaConcentration (::std::unique_ptr< PlasmaConcentration_type > x)
          {
            this->PlasmaConcentration_.set (std::move (x));
          }
  
          const SubstanceData::SystemicMassCleared_optional& SubstanceData::
          SystemicMassCleared () const
          {
            return this->SystemicMassCleared_;
          }
  
          SubstanceData::SystemicMassCleared_optional& SubstanceData::
          SystemicMassCleared ()
          {
            return this->SystemicMassCleared_;
          }
  
          void SubstanceData::
          SystemicMassCleared (const SystemicMassCleared_type& x)
          {
            this->SystemicMassCleared_.set (x);
          }
  
          void SubstanceData::
          SystemicMassCleared (const SystemicMassCleared_optional& x)
          {
            this->SystemicMassCleared_ = x;
          }
  
          void SubstanceData::
          SystemicMassCleared (::std::unique_ptr< SystemicMassCleared_type > x)
          {
            this->SystemicMassCleared_.set (std::move (x));
          }
  
          const SubstanceData::TissueConcentration_optional& SubstanceData::
          TissueConcentration () const
          {
            return this->TissueConcentration_;
          }
  
          SubstanceData::TissueConcentration_optional& SubstanceData::
          TissueConcentration ()
          {
            return this->TissueConcentration_;
          }
  
          void SubstanceData::
          TissueConcentration (const TissueConcentration_type& x)
          {
            this->TissueConcentration_.set (x);
          }
  
          void SubstanceData::
          TissueConcentration (const TissueConcentration_optional& x)
          {
            this->TissueConcentration_ = x;
          }
  
          void SubstanceData::
          TissueConcentration (::std::unique_ptr< TissueConcentration_type > x)
          {
            this->TissueConcentration_.set (std::move (x));
          }
  
          const SubstanceData::AlveolarTransfer_optional& SubstanceData::
          AlveolarTransfer () const
          {
            return this->AlveolarTransfer_;
          }
  
          SubstanceData::AlveolarTransfer_optional& SubstanceData::
          AlveolarTransfer ()
          {
            return this->AlveolarTransfer_;
          }
  
          void SubstanceData::
          AlveolarTransfer (const AlveolarTransfer_type& x)
          {
            this->AlveolarTransfer_.set (x);
          }
  
          void SubstanceData::
          AlveolarTransfer (const AlveolarTransfer_optional& x)
          {
            this->AlveolarTransfer_ = x;
          }
  
          void SubstanceData::
          AlveolarTransfer (::std::unique_ptr< AlveolarTransfer_type > x)
          {
            this->AlveolarTransfer_.set (std::move (x));
          }
  
          const SubstanceData::DiffusingCapacity_optional& SubstanceData::
          DiffusingCapacity () const
          {
            return this->DiffusingCapacity_;
          }
  
          SubstanceData::DiffusingCapacity_optional& SubstanceData::
          DiffusingCapacity ()
          {
            return this->DiffusingCapacity_;
          }
  
          void SubstanceData::
          DiffusingCapacity (const DiffusingCapacity_type& x)
          {
            this->DiffusingCapacity_.set (x);
          }
  
          void SubstanceData::
          DiffusingCapacity (const DiffusingCapacity_optional& x)
          {
            this->DiffusingCapacity_ = x;
          }
  
          void SubstanceData::
          DiffusingCapacity (::std::unique_ptr< DiffusingCapacity_type > x)
          {
            this->DiffusingCapacity_.set (std::move (x));
          }
  
          const SubstanceData::EndTidalFraction_optional& SubstanceData::
          EndTidalFraction () const
          {
            return this->EndTidalFraction_;
          }
  
          SubstanceData::EndTidalFraction_optional& SubstanceData::
          EndTidalFraction ()
          {
            return this->EndTidalFraction_;
          }
  
          void SubstanceData::
          EndTidalFraction (const EndTidalFraction_type& x)
          {
            this->EndTidalFraction_.set (x);
          }
  
          void SubstanceData::
          EndTidalFraction (const EndTidalFraction_optional& x)
          {
            this->EndTidalFraction_ = x;
          }
  
          void SubstanceData::
          EndTidalFraction (::std::unique_ptr< EndTidalFraction_type > x)
          {
            this->EndTidalFraction_.set (std::move (x));
          }
  
          const SubstanceData::EndTidalPressure_optional& SubstanceData::
          EndTidalPressure () const
          {
            return this->EndTidalPressure_;
          }
  
          SubstanceData::EndTidalPressure_optional& SubstanceData::
          EndTidalPressure ()
          {
            return this->EndTidalPressure_;
          }
  
          void SubstanceData::
          EndTidalPressure (const EndTidalPressure_type& x)
          {
            this->EndTidalPressure_.set (x);
          }
  
          void SubstanceData::
          EndTidalPressure (const EndTidalPressure_optional& x)
          {
            this->EndTidalPressure_ = x;
          }
  
          void SubstanceData::
          EndTidalPressure (::std::unique_ptr< EndTidalPressure_type > x)
          {
            this->EndTidalPressure_.set (std::move (x));
          }
  
          const SubstanceData::RelativeDiffusionCoefficient_optional& SubstanceData::
          RelativeDiffusionCoefficient () const
          {
            return this->RelativeDiffusionCoefficient_;
          }
  
          SubstanceData::RelativeDiffusionCoefficient_optional& SubstanceData::
          RelativeDiffusionCoefficient ()
          {
            return this->RelativeDiffusionCoefficient_;
          }
  
          void SubstanceData::
          RelativeDiffusionCoefficient (const RelativeDiffusionCoefficient_type& x)
          {
            this->RelativeDiffusionCoefficient_.set (x);
          }
  
          void SubstanceData::
          RelativeDiffusionCoefficient (const RelativeDiffusionCoefficient_optional& x)
          {
            this->RelativeDiffusionCoefficient_ = x;
          }
  
          void SubstanceData::
          RelativeDiffusionCoefficient (::std::unique_ptr< RelativeDiffusionCoefficient_type > x)
          {
            this->RelativeDiffusionCoefficient_.set (std::move (x));
          }
  
          const SubstanceData::SolubilityCoefficient_optional& SubstanceData::
          SolubilityCoefficient () const
          {
            return this->SolubilityCoefficient_;
          }
  
          SubstanceData::SolubilityCoefficient_optional& SubstanceData::
          SolubilityCoefficient ()
          {
            return this->SolubilityCoefficient_;
          }
  
          void SubstanceData::
          SolubilityCoefficient (const SolubilityCoefficient_type& x)
          {
            this->SolubilityCoefficient_.set (x);
          }
  
          void SubstanceData::
          SolubilityCoefficient (const SolubilityCoefficient_optional& x)
          {
            this->SolubilityCoefficient_ = x;
          }
  
          void SubstanceData::
          SolubilityCoefficient (::std::unique_ptr< SolubilityCoefficient_type > x)
          {
            this->SolubilityCoefficient_.set (std::move (x));
          }
  
          const SubstanceData::Clearance_optional& SubstanceData::
          Clearance () const
          {
            return this->Clearance_;
          }
  
          SubstanceData::Clearance_optional& SubstanceData::
          Clearance ()
          {
            return this->Clearance_;
          }
  
          void SubstanceData::
          Clearance (const Clearance_type& x)
          {
            this->Clearance_.set (x);
          }
  
          void SubstanceData::
          Clearance (const Clearance_optional& x)
          {
            this->Clearance_ = x;
          }
  
          void SubstanceData::
          Clearance (::std::unique_ptr< Clearance_type > x)
          {
            this->Clearance_.set (std::move (x));
          }
  
          const SubstanceData::Pharmacokinetics_optional& SubstanceData::
          Pharmacokinetics () const
          {
            return this->Pharmacokinetics_;
          }
  
          SubstanceData::Pharmacokinetics_optional& SubstanceData::
          Pharmacokinetics ()
          {
            return this->Pharmacokinetics_;
          }
  
          void SubstanceData::
          Pharmacokinetics (const Pharmacokinetics_type& x)
          {
            this->Pharmacokinetics_.set (x);
          }
  
          void SubstanceData::
          Pharmacokinetics (const Pharmacokinetics_optional& x)
          {
            this->Pharmacokinetics_ = x;
          }
  
          void SubstanceData::
          Pharmacokinetics (::std::unique_ptr< Pharmacokinetics_type > x)
          {
            this->Pharmacokinetics_.set (std::move (x));
          }
  
          const SubstanceData::Pharmacodynamics_optional& SubstanceData::
          Pharmacodynamics () const
          {
            return this->Pharmacodynamics_;
          }
  
          SubstanceData::Pharmacodynamics_optional& SubstanceData::
          Pharmacodynamics ()
          {
            return this->Pharmacodynamics_;
          }
  
          void SubstanceData::
          Pharmacodynamics (const Pharmacodynamics_type& x)
          {
            this->Pharmacodynamics_.set (x);
          }
  
          void SubstanceData::
          Pharmacodynamics (const Pharmacodynamics_optional& x)
          {
            this->Pharmacodynamics_ = x;
          }
  
          void SubstanceData::
          Pharmacodynamics (::std::unique_ptr< Pharmacodynamics_type > x)
          {
            this->Pharmacodynamics_.set (std::move (x));
          }
  
  
          // SubstanceCompoundData
          // 
  
          const SubstanceCompoundData::Name_type& SubstanceCompoundData::
          Name () const
          {
            return this->Name_.get ();
          }
  
          SubstanceCompoundData::Name_type& SubstanceCompoundData::
          Name ()
          {
            return this->Name_.get ();
          }
  
          void SubstanceCompoundData::
          Name (const Name_type& x)
          {
            this->Name_.set (x);
          }
  
          void SubstanceCompoundData::
          Name (::std::unique_ptr< Name_type > x)
          {
            this->Name_.set (std::move (x));
          }
  
          const SubstanceCompoundData::Classification_optional& SubstanceCompoundData::
          Classification () const
          {
            return this->Classification_;
          }
  
          SubstanceCompoundData::Classification_optional& SubstanceCompoundData::
          Classification ()
          {
            return this->Classification_;
          }
  
          void SubstanceCompoundData::
          Classification (const Classification_type& x)
          {
            this->Classification_.set (x);
          }
  
          void SubstanceCompoundData::
          Classification (const Classification_optional& x)
          {
            this->Classification_ = x;
          }
  
          void SubstanceCompoundData::
          Classification (::std::unique_ptr< Classification_type > x)
          {
            this->Classification_.set (std::move (x));
          }
  
          const SubstanceCompoundData::BloodRHFactor_optional& SubstanceCompoundData::
          BloodRHFactor () const
          {
            return this->BloodRHFactor_;
          }
  
          SubstanceCompoundData::BloodRHFactor_optional& SubstanceCompoundData::
          BloodRHFactor ()
          {
            return this->BloodRHFactor_;
          }
  
          void SubstanceCompoundData::
          BloodRHFactor (const BloodRHFactor_type& x)
          {
            this->BloodRHFactor_.set (x);
          }
  
          void SubstanceCompoundData::
          BloodRHFactor (const BloodRHFactor_optional& x)
          {
            this->BloodRHFactor_ = x;
          }
  
          const SubstanceCompoundData::Component_sequence& SubstanceCompoundData::
          Component () const
          {
            return this->Component_;
          }
  
          SubstanceCompoundData::Component_sequence& SubstanceCompoundData::
          Component ()
          {
            return this->Component_;
          }
  
          void SubstanceCompoundData::
          Component (const Component_sequence& s)
          {
            this->Component_ = s;
          }
  
  
          // SubstanceFractionData
          // 
  
          const SubstanceFractionData::FractionAmount_type& SubstanceFractionData::
          FractionAmount () const
          {
            return this->FractionAmount_.get ();
          }
  
          SubstanceFractionData::FractionAmount_type& SubstanceFractionData::
          FractionAmount ()
          {
            return this->FractionAmount_.get ();
          }
  
          void SubstanceFractionData::
          FractionAmount (const FractionAmount_type& x)
          {
            this->FractionAmount_.set (x);
          }
  
          void SubstanceFractionData::
          FractionAmount (::std::unique_ptr< FractionAmount_type > x)
          {
            this->FractionAmount_.set (std::move (x));
          }
  
          const SubstanceFractionData::Name_type& SubstanceFractionData::
          Name () const
          {
            return this->Name_.get ();
          }
  
          SubstanceFractionData::Name_type& SubstanceFractionData::
          Name ()
          {
            return this->Name_.get ();
          }
  
          void SubstanceFractionData::
          Name (const Name_type& x)
          {
            this->Name_.set (x);
          }
  
          void SubstanceFractionData::
          Name (::std::unique_ptr< Name_type > x)
          {
            this->Name_.set (std::move (x));
          }
  
  
          // SubstanceConcentrationData
          // 
  
          const SubstanceConcentrationData::Concentration_type& SubstanceConcentrationData::
          Concentration () const
          {
            return this->Concentration_.get ();
          }
  
          SubstanceConcentrationData::Concentration_type& SubstanceConcentrationData::
          Concentration ()
          {
            return this->Concentration_.get ();
          }
  
          void SubstanceConcentrationData::
          Concentration (const Concentration_type& x)
          {
            this->Concentration_.set (x);
          }
  
          void SubstanceConcentrationData::
          Concentration (::std::unique_ptr< Concentration_type > x)
          {
            this->Concentration_.set (std::move (x));
          }
  
          const SubstanceConcentrationData::Name_type& SubstanceConcentrationData::
          Name () const
          {
            return this->Name_.get ();
          }
  
          SubstanceConcentrationData::Name_type& SubstanceConcentrationData::
          Name ()
          {
            return this->Name_.get ();
          }
  
          void SubstanceConcentrationData::
          Name (const Name_type& x)
          {
            this->Name_.set (x);
          }
  
          void SubstanceConcentrationData::
          Name (::std::unique_ptr< Name_type > x)
          {
            this->Name_.set (std::move (x));
          }
  
  
          // PharmacodynamicModifierData
          // 
  
          const PharmacodynamicModifierData::EMax_type& PharmacodynamicModifierData::
          EMax () const
          {
            return this->EMax_.get ();
          }
  
          PharmacodynamicModifierData::EMax_type& PharmacodynamicModifierData::
          EMax ()
          {
            return this->EMax_.get ();
          }
  
          void PharmacodynamicModifierData::
          EMax (const EMax_type& x)
          {
            this->EMax_.set (x);
          }
  
          void PharmacodynamicModifierData::
          EMax (::std::unique_ptr< EMax_type > x)
          {
            this->EMax_.set (std::move (x));
          }
  
          const PharmacodynamicModifierData::EC50_type& PharmacodynamicModifierData::
          EC50 () const
          {
            return this->EC50_.get ();
          }
  
          PharmacodynamicModifierData::EC50_type& PharmacodynamicModifierData::
          EC50 ()
          {
            return this->EC50_.get ();
          }
  
          void PharmacodynamicModifierData::
          EC50 (const EC50_type& x)
          {
            this->EC50_.set (x);
          }
  
          void PharmacodynamicModifierData::
          EC50 (::std::unique_ptr< EC50_type > x)
          {
            this->EC50_.set (std::move (x));
          }
  
  
          // Systemic
          // 
  
          const Systemic::FractionExcretedInFeces_type& Systemic::
          FractionExcretedInFeces () const
          {
            return this->FractionExcretedInFeces_.get ();
          }
  
          Systemic::FractionExcretedInFeces_type& Systemic::
          FractionExcretedInFeces ()
          {
            return this->FractionExcretedInFeces_.get ();
          }
  
          void Systemic::
          FractionExcretedInFeces (const FractionExcretedInFeces_type& x)
          {
            this->FractionExcretedInFeces_.set (x);
          }
  
          void Systemic::
          FractionExcretedInFeces (::std::unique_ptr< FractionExcretedInFeces_type > x)
          {
            this->FractionExcretedInFeces_.set (std::move (x));
          }
  
          const Systemic::FractionExcretedInUrine_optional& Systemic::
          FractionExcretedInUrine () const
          {
            return this->FractionExcretedInUrine_;
          }
  
          Systemic::FractionExcretedInUrine_optional& Systemic::
          FractionExcretedInUrine ()
          {
            return this->FractionExcretedInUrine_;
          }
  
          void Systemic::
          FractionExcretedInUrine (const FractionExcretedInUrine_type& x)
          {
            this->FractionExcretedInUrine_.set (x);
          }
  
          void Systemic::
          FractionExcretedInUrine (const FractionExcretedInUrine_optional& x)
          {
            this->FractionExcretedInUrine_ = x;
          }
  
          void Systemic::
          FractionExcretedInUrine (::std::unique_ptr< FractionExcretedInUrine_type > x)
          {
            this->FractionExcretedInUrine_.set (std::move (x));
          }
  
          const Systemic::FractionMetabolizedInGut_optional& Systemic::
          FractionMetabolizedInGut () const
          {
            return this->FractionMetabolizedInGut_;
          }
  
          Systemic::FractionMetabolizedInGut_optional& Systemic::
          FractionMetabolizedInGut ()
          {
            return this->FractionMetabolizedInGut_;
          }
  
          void Systemic::
          FractionMetabolizedInGut (const FractionMetabolizedInGut_type& x)
          {
            this->FractionMetabolizedInGut_.set (x);
          }
  
          void Systemic::
          FractionMetabolizedInGut (const FractionMetabolizedInGut_optional& x)
          {
            this->FractionMetabolizedInGut_ = x;
          }
  
          void Systemic::
          FractionMetabolizedInGut (::std::unique_ptr< FractionMetabolizedInGut_type > x)
          {
            this->FractionMetabolizedInGut_.set (std::move (x));
          }
  
          const Systemic::FractionUnboundInPlasma_type& Systemic::
          FractionUnboundInPlasma () const
          {
            return this->FractionUnboundInPlasma_.get ();
          }
  
          Systemic::FractionUnboundInPlasma_type& Systemic::
          FractionUnboundInPlasma ()
          {
            return this->FractionUnboundInPlasma_.get ();
          }
  
          void Systemic::
          FractionUnboundInPlasma (const FractionUnboundInPlasma_type& x)
          {
            this->FractionUnboundInPlasma_.set (x);
          }
  
          void Systemic::
          FractionUnboundInPlasma (::std::unique_ptr< FractionUnboundInPlasma_type > x)
          {
            this->FractionUnboundInPlasma_.set (std::move (x));
          }
  
          const Systemic::IntrinsicClearance_type& Systemic::
          IntrinsicClearance () const
          {
            return this->IntrinsicClearance_.get ();
          }
  
          Systemic::IntrinsicClearance_type& Systemic::
          IntrinsicClearance ()
          {
            return this->IntrinsicClearance_.get ();
          }
  
          void Systemic::
          IntrinsicClearance (const IntrinsicClearance_type& x)
          {
            this->IntrinsicClearance_.set (x);
          }
  
          void Systemic::
          IntrinsicClearance (::std::unique_ptr< IntrinsicClearance_type > x)
          {
            this->IntrinsicClearance_.set (std::move (x));
          }
  
          const Systemic::RenalClearance_type& Systemic::
          RenalClearance () const
          {
            return this->RenalClearance_.get ();
          }
  
          Systemic::RenalClearance_type& Systemic::
          RenalClearance ()
          {
            return this->RenalClearance_.get ();
          }
  
          void Systemic::
          RenalClearance (const RenalClearance_type& x)
          {
            this->RenalClearance_.set (x);
          }
  
          void Systemic::
          RenalClearance (::std::unique_ptr< RenalClearance_type > x)
          {
            this->RenalClearance_.set (std::move (x));
          }
  
          const Systemic::SystemicClearance_type& Systemic::
          SystemicClearance () const
          {
            return this->SystemicClearance_.get ();
          }
  
          Systemic::SystemicClearance_type& Systemic::
          SystemicClearance ()
          {
            return this->SystemicClearance_.get ();
          }
  
          void Systemic::
          SystemicClearance (const SystemicClearance_type& x)
          {
            this->SystemicClearance_.set (x);
          }
  
          void Systemic::
          SystemicClearance (::std::unique_ptr< SystemicClearance_type > x)
          {
            this->SystemicClearance_.set (std::move (x));
          }
  
  
          // RenalDynamics
          // 
  
          const RenalDynamics::Clearance_optional& RenalDynamics::
          Clearance () const
          {
            return this->Clearance_;
          }
  
          RenalDynamics::Clearance_optional& RenalDynamics::
          Clearance ()
          {
            return this->Clearance_;
          }
  
          void RenalDynamics::
          Clearance (const Clearance_type& x)
          {
            this->Clearance_.set (x);
          }
  
          void RenalDynamics::
          Clearance (const Clearance_optional& x)
          {
            this->Clearance_ = x;
          }
  
          void RenalDynamics::
          Clearance (::std::unique_ptr< Clearance_type > x)
          {
            this->Clearance_.set (std::move (x));
          }
  
          const RenalDynamics::Regulation_optional& RenalDynamics::
          Regulation () const
          {
            return this->Regulation_;
          }
  
          RenalDynamics::Regulation_optional& RenalDynamics::
          Regulation ()
          {
            return this->Regulation_;
          }
  
          void RenalDynamics::
          Regulation (const Regulation_type& x)
          {
            this->Regulation_.set (x);
          }
  
          void RenalDynamics::
          Regulation (const Regulation_optional& x)
          {
            this->Regulation_ = x;
          }
  
          void RenalDynamics::
          Regulation (::std::unique_ptr< Regulation_type > x)
          {
            this->Regulation_.set (std::move (x));
          }
  
          const RenalDynamics::FiltrationRate_optional& RenalDynamics::
          FiltrationRate () const
          {
            return this->FiltrationRate_;
          }
  
          RenalDynamics::FiltrationRate_optional& RenalDynamics::
          FiltrationRate ()
          {
            return this->FiltrationRate_;
          }
  
          void RenalDynamics::
          FiltrationRate (const FiltrationRate_type& x)
          {
            this->FiltrationRate_.set (x);
          }
  
          void RenalDynamics::
          FiltrationRate (const FiltrationRate_optional& x)
          {
            this->FiltrationRate_ = x;
          }
  
          void RenalDynamics::
          FiltrationRate (::std::unique_ptr< FiltrationRate_type > x)
          {
            this->FiltrationRate_.set (std::move (x));
          }
  
          const RenalDynamics::ReabsorptionRate_optional& RenalDynamics::
          ReabsorptionRate () const
          {
            return this->ReabsorptionRate_;
          }
  
          RenalDynamics::ReabsorptionRate_optional& RenalDynamics::
          ReabsorptionRate ()
          {
            return this->ReabsorptionRate_;
          }
  
          void RenalDynamics::
          ReabsorptionRate (const ReabsorptionRate_type& x)
          {
            this->ReabsorptionRate_.set (x);
          }
  
          void RenalDynamics::
          ReabsorptionRate (const ReabsorptionRate_optional& x)
          {
            this->ReabsorptionRate_ = x;
          }
  
          void RenalDynamics::
          ReabsorptionRate (::std::unique_ptr< ReabsorptionRate_type > x)
          {
            this->ReabsorptionRate_.set (std::move (x));
          }
  
          const RenalDynamics::ExcretionRate_optional& RenalDynamics::
          ExcretionRate () const
          {
            return this->ExcretionRate_;
          }
  
          RenalDynamics::ExcretionRate_optional& RenalDynamics::
          ExcretionRate ()
          {
            return this->ExcretionRate_;
          }
  
          void RenalDynamics::
          ExcretionRate (const ExcretionRate_type& x)
          {
            this->ExcretionRate_.set (x);
          }
  
          void RenalDynamics::
          ExcretionRate (const ExcretionRate_optional& x)
          {
            this->ExcretionRate_ = x;
          }
  
          void RenalDynamics::
          ExcretionRate (::std::unique_ptr< ExcretionRate_type > x)
          {
            this->ExcretionRate_.set (std::move (x));
          }
  
          const RenalDynamics::GlomerularFilterability_optional& RenalDynamics::
          GlomerularFilterability () const
          {
            return this->GlomerularFilterability_;
          }
  
          RenalDynamics::GlomerularFilterability_optional& RenalDynamics::
          GlomerularFilterability ()
          {
            return this->GlomerularFilterability_;
          }
  
          void RenalDynamics::
          GlomerularFilterability (const GlomerularFilterability_type& x)
          {
            this->GlomerularFilterability_.set (x);
          }
  
          void RenalDynamics::
          GlomerularFilterability (const GlomerularFilterability_optional& x)
          {
            this->GlomerularFilterability_ = x;
          }
  
          void RenalDynamics::
          GlomerularFilterability (::std::unique_ptr< GlomerularFilterability_type > x)
          {
            this->GlomerularFilterability_.set (std::move (x));
          }
  
  
          // CellRegulation
          // 
  
          const CellRegulation::CellDeathRate_type& CellRegulation::
          CellDeathRate () const
          {
            return this->CellDeathRate_.get ();
          }
  
          CellRegulation::CellDeathRate_type& CellRegulation::
          CellDeathRate ()
          {
            return this->CellDeathRate_.get ();
          }
  
          void CellRegulation::
          CellDeathRate (const CellDeathRate_type& x)
          {
            this->CellDeathRate_.set (x);
          }
  
          void CellRegulation::
          CellDeathRate (::std::unique_ptr< CellDeathRate_type > x)
          {
            this->CellDeathRate_.set (std::move (x));
          }
  
          const CellRegulation::CellBirthRate_type& CellRegulation::
          CellBirthRate () const
          {
            return this->CellBirthRate_.get ();
          }
  
          CellRegulation::CellBirthRate_type& CellRegulation::
          CellBirthRate ()
          {
            return this->CellBirthRate_.get ();
          }
  
          void CellRegulation::
          CellBirthRate (const CellBirthRate_type& x)
          {
            this->CellBirthRate_.set (x);
          }
  
          void CellRegulation::
          CellBirthRate (::std::unique_ptr< CellBirthRate_type > x)
          {
            this->CellBirthRate_.set (std::move (x));
          }
  
  
          // Regulation
          // 
  
          const Regulation::ChargeInBlood_type& Regulation::
          ChargeInBlood () const
          {
            return this->ChargeInBlood_.get ();
          }
  
          Regulation::ChargeInBlood_type& Regulation::
          ChargeInBlood ()
          {
            return this->ChargeInBlood_.get ();
          }
  
          void Regulation::
          ChargeInBlood (const ChargeInBlood_type& x)
          {
            this->ChargeInBlood_.set (x);
          }
  
          void Regulation::
          ChargeInBlood (::std::unique_ptr< ChargeInBlood_type > x)
          {
            this->ChargeInBlood_.set (std::move (x));
          }
  
          const Regulation::FractionUnboundInPlasma_type& Regulation::
          FractionUnboundInPlasma () const
          {
            return this->FractionUnboundInPlasma_.get ();
          }
  
          Regulation::FractionUnboundInPlasma_type& Regulation::
          FractionUnboundInPlasma ()
          {
            return this->FractionUnboundInPlasma_.get ();
          }
  
          void Regulation::
          FractionUnboundInPlasma (const FractionUnboundInPlasma_type& x)
          {
            this->FractionUnboundInPlasma_.set (x);
          }
  
          void Regulation::
          FractionUnboundInPlasma (::std::unique_ptr< FractionUnboundInPlasma_type > x)
          {
            this->FractionUnboundInPlasma_.set (std::move (x));
          }
  
          const Regulation::ReabsorptionRatio_type& Regulation::
          ReabsorptionRatio () const
          {
            return this->ReabsorptionRatio_.get ();
          }
  
          Regulation::ReabsorptionRatio_type& Regulation::
          ReabsorptionRatio ()
          {
            return this->ReabsorptionRatio_.get ();
          }
  
          void Regulation::
          ReabsorptionRatio (const ReabsorptionRatio_type& x)
          {
            this->ReabsorptionRatio_.set (x);
          }
  
          void Regulation::
          ReabsorptionRatio (::std::unique_ptr< ReabsorptionRatio_type > x)
          {
            this->ReabsorptionRatio_.set (std::move (x));
          }
  
          const Regulation::TransportMaximum_type& Regulation::
          TransportMaximum () const
          {
            return this->TransportMaximum_.get ();
          }
  
          Regulation::TransportMaximum_type& Regulation::
          TransportMaximum ()
          {
            return this->TransportMaximum_.get ();
          }
  
          void Regulation::
          TransportMaximum (const TransportMaximum_type& x)
          {
            this->TransportMaximum_.set (x);
          }
  
          void Regulation::
          TransportMaximum (::std::unique_ptr< TransportMaximum_type > x)
          {
            this->TransportMaximum_.set (std::move (x));
          }
        }
      }
    }
  }
  
  #include <xsd/cxx/xml/dom/parsing-source.hxx>
  
  #include <xsd/cxx/tree/type-factory-map.hxx>
  
  namespace _xsd
  {
    static
    const ::xsd::cxx::tree::type_factory_plate< 0, char >
    type_factory_plate_init;
  }
  
  namespace mil
  {
    namespace tatrc
    {
      namespace physiology
      {
        namespace datamodel
        {
          // enumSubstanceState
          //
  
          enumSubstanceState::
          enumSubstanceState (const ::xercesc::DOMElement& e,
                              ::xml_schema::flags f,
                              ::xml_schema::container* c)
          : ::xml_schema::string (e, f, c)
          {
            _xsd_enumSubstanceState_convert ();
          }
  
          enumSubstanceState::
          enumSubstanceState (const ::xercesc::DOMAttr& a,
                              ::xml_schema::flags f,
                              ::xml_schema::container* c)
          : ::xml_schema::string (a, f, c)
          {
            _xsd_enumSubstanceState_convert ();
          }
  
          enumSubstanceState::
          enumSubstanceState (const ::std::string& s,
                              const ::xercesc::DOMElement* e,
                              ::xml_schema::flags f,
                              ::xml_schema::container* c)
          : ::xml_schema::string (s, e, f, c)
          {
            _xsd_enumSubstanceState_convert ();
          }
  
          enumSubstanceState* enumSubstanceState::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class enumSubstanceState (*this, f, c);
          }
  
          enumSubstanceState::value enumSubstanceState::
          _xsd_enumSubstanceState_convert () const
          {
            ::xsd::cxx::tree::enum_comparator< char > c (_xsd_enumSubstanceState_literals_);
            const value* i (::std::lower_bound (
                              _xsd_enumSubstanceState_indexes_,
                              _xsd_enumSubstanceState_indexes_ + 4,
                              *this,
                              c));
  
            if (i == _xsd_enumSubstanceState_indexes_ + 4 || _xsd_enumSubstanceState_literals_[*i] != *this)
            {
              throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this);
            }
  
            return *i;
          }
  
          const char* const enumSubstanceState::
          _xsd_enumSubstanceState_literals_[4] =
          {
            "Solid",
            "Liquid",
            "Gas",
            "Molecular"
          };
  
          const enumSubstanceState::value enumSubstanceState::
          _xsd_enumSubstanceState_indexes_[4] =
          {
            ::mil::tatrc::physiology::datamodel::enumSubstanceState::Gas,
            ::mil::tatrc::physiology::datamodel::enumSubstanceState::Liquid,
            ::mil::tatrc::physiology::datamodel::enumSubstanceState::Molecular,
            ::mil::tatrc::physiology::datamodel::enumSubstanceState::Solid
          };
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, enumSubstanceState >
          _xsd_enumSubstanceState_type_factory_init (
            "enumSubstanceState",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // enumSubstanceIonicState
          //
  
          enumSubstanceIonicState::
          enumSubstanceIonicState (const ::xercesc::DOMElement& e,
                                   ::xml_schema::flags f,
                                   ::xml_schema::container* c)
          : ::xml_schema::string (e, f, c)
          {
            _xsd_enumSubstanceIonicState_convert ();
          }
  
          enumSubstanceIonicState::
          enumSubstanceIonicState (const ::xercesc::DOMAttr& a,
                                   ::xml_schema::flags f,
                                   ::xml_schema::container* c)
          : ::xml_schema::string (a, f, c)
          {
            _xsd_enumSubstanceIonicState_convert ();
          }
  
          enumSubstanceIonicState::
          enumSubstanceIonicState (const ::std::string& s,
                                   const ::xercesc::DOMElement* e,
                                   ::xml_schema::flags f,
                                   ::xml_schema::container* c)
          : ::xml_schema::string (s, e, f, c)
          {
            _xsd_enumSubstanceIonicState_convert ();
          }
  
          enumSubstanceIonicState* enumSubstanceIonicState::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class enumSubstanceIonicState (*this, f, c);
          }
  
          enumSubstanceIonicState::value enumSubstanceIonicState::
          _xsd_enumSubstanceIonicState_convert () const
          {
            ::xsd::cxx::tree::enum_comparator< char > c (_xsd_enumSubstanceIonicState_literals_);
            const value* i (::std::lower_bound (
                              _xsd_enumSubstanceIonicState_indexes_,
                              _xsd_enumSubstanceIonicState_indexes_ + 5,
                              *this,
                              c));
  
            if (i == _xsd_enumSubstanceIonicState_indexes_ + 5 || _xsd_enumSubstanceIonicState_literals_[*i] != *this)
            {
              throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this);
            }
  
            return *i;
          }
  
          const char* const enumSubstanceIonicState::
          _xsd_enumSubstanceIonicState_literals_[5] =
          {
            "WeakBase",
            "Base",
            "Acid",
            "Neutral",
            "Zwitterion"
          };
  
          const enumSubstanceIonicState::value enumSubstanceIonicState::
          _xsd_enumSubstanceIonicState_indexes_[5] =
          {
            ::mil::tatrc::physiology::datamodel::enumSubstanceIonicState::Acid,
            ::mil::tatrc::physiology::datamodel::enumSubstanceIonicState::Base,
            ::mil::tatrc::physiology::datamodel::enumSubstanceIonicState::Neutral,
            ::mil::tatrc::physiology::datamodel::enumSubstanceIonicState::WeakBase,
            ::mil::tatrc::physiology::datamodel::enumSubstanceIonicState::Zwitterion
          };
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, enumSubstanceIonicState >
          _xsd_enumSubstanceIonicState_type_factory_init (
            "enumSubstanceIonicState",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // enumSubstanceBindingProtein
          //
  
          enumSubstanceBindingProtein::
          enumSubstanceBindingProtein (const ::xercesc::DOMElement& e,
                                       ::xml_schema::flags f,
                                       ::xml_schema::container* c)
          : ::xml_schema::string (e, f, c)
          {
            _xsd_enumSubstanceBindingProtein_convert ();
          }
  
          enumSubstanceBindingProtein::
          enumSubstanceBindingProtein (const ::xercesc::DOMAttr& a,
                                       ::xml_schema::flags f,
                                       ::xml_schema::container* c)
          : ::xml_schema::string (a, f, c)
          {
            _xsd_enumSubstanceBindingProtein_convert ();
          }
  
          enumSubstanceBindingProtein::
          enumSubstanceBindingProtein (const ::std::string& s,
                                       const ::xercesc::DOMElement* e,
                                       ::xml_schema::flags f,
                                       ::xml_schema::container* c)
          : ::xml_schema::string (s, e, f, c)
          {
            _xsd_enumSubstanceBindingProtein_convert ();
          }
  
          enumSubstanceBindingProtein* enumSubstanceBindingProtein::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class enumSubstanceBindingProtein (*this, f, c);
          }
  
          enumSubstanceBindingProtein::value enumSubstanceBindingProtein::
          _xsd_enumSubstanceBindingProtein_convert () const
          {
            ::xsd::cxx::tree::enum_comparator< char > c (_xsd_enumSubstanceBindingProtein_literals_);
            const value* i (::std::lower_bound (
                              _xsd_enumSubstanceBindingProtein_indexes_,
                              _xsd_enumSubstanceBindingProtein_indexes_ + 3,
                              *this,
                              c));
  
            if (i == _xsd_enumSubstanceBindingProtein_indexes_ + 3 || _xsd_enumSubstanceBindingProtein_literals_[*i] != *this)
            {
              throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this);
            }
  
            return *i;
          }
  
          const char* const enumSubstanceBindingProtein::
          _xsd_enumSubstanceBindingProtein_literals_[3] =
          {
            "Albumin",
            "Lipoprotein",
            "AAG"
          };
  
          const enumSubstanceBindingProtein::value enumSubstanceBindingProtein::
          _xsd_enumSubstanceBindingProtein_indexes_[3] =
          {
            ::mil::tatrc::physiology::datamodel::enumSubstanceBindingProtein::AAG,
            ::mil::tatrc::physiology::datamodel::enumSubstanceBindingProtein::Albumin,
            ::mil::tatrc::physiology::datamodel::enumSubstanceBindingProtein::Lipoprotein
          };
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, enumSubstanceBindingProtein >
          _xsd_enumSubstanceBindingProtein_type_factory_init (
            "enumSubstanceBindingProtein",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // enumCharge
          //
  
          enumCharge::
          enumCharge (const ::xercesc::DOMElement& e,
                      ::xml_schema::flags f,
                      ::xml_schema::container* c)
          : ::xml_schema::string (e, f, c)
          {
            _xsd_enumCharge_convert ();
          }
  
          enumCharge::
          enumCharge (const ::xercesc::DOMAttr& a,
                      ::xml_schema::flags f,
                      ::xml_schema::container* c)
          : ::xml_schema::string (a, f, c)
          {
            _xsd_enumCharge_convert ();
          }
  
          enumCharge::
          enumCharge (const ::std::string& s,
                      const ::xercesc::DOMElement* e,
                      ::xml_schema::flags f,
                      ::xml_schema::container* c)
          : ::xml_schema::string (s, e, f, c)
          {
            _xsd_enumCharge_convert ();
          }
  
          enumCharge* enumCharge::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class enumCharge (*this, f, c);
          }
  
          enumCharge::value enumCharge::
          _xsd_enumCharge_convert () const
          {
            ::xsd::cxx::tree::enum_comparator< char > c (_xsd_enumCharge_literals_);
            const value* i (::std::lower_bound (
                              _xsd_enumCharge_indexes_,
                              _xsd_enumCharge_indexes_ + 3,
                              *this,
                              c));
  
            if (i == _xsd_enumCharge_indexes_ + 3 || _xsd_enumCharge_literals_[*i] != *this)
            {
              throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this);
            }
  
            return *i;
          }
  
          const char* const enumCharge::
          _xsd_enumCharge_literals_[3] =
          {
            "Positive",
            "Negative",
            "Neutral"
          };
  
          const enumCharge::value enumCharge::
          _xsd_enumCharge_indexes_[3] =
          {
            ::mil::tatrc::physiology::datamodel::enumCharge::Negative,
            ::mil::tatrc::physiology::datamodel::enumCharge::Neutral,
            ::mil::tatrc::physiology::datamodel::enumCharge::Positive
          };
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, enumCharge >
          _xsd_enumCharge_type_factory_init (
            "enumCharge",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // enumSubstanceClass
          //
  
          enumSubstanceClass::
          enumSubstanceClass (const ::xercesc::DOMElement& e,
                              ::xml_schema::flags f,
                              ::xml_schema::container* c)
          : ::xml_schema::string (e, f, c)
          {
            _xsd_enumSubstanceClass_convert ();
          }
  
          enumSubstanceClass::
          enumSubstanceClass (const ::xercesc::DOMAttr& a,
                              ::xml_schema::flags f,
                              ::xml_schema::container* c)
          : ::xml_schema::string (a, f, c)
          {
            _xsd_enumSubstanceClass_convert ();
          }
  
          enumSubstanceClass::
          enumSubstanceClass (const ::std::string& s,
                              const ::xercesc::DOMElement* e,
                              ::xml_schema::flags f,
                              ::xml_schema::container* c)
          : ::xml_schema::string (s, e, f, c)
          {
            _xsd_enumSubstanceClass_convert ();
          }
  
          enumSubstanceClass* enumSubstanceClass::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class enumSubstanceClass (*this, f, c);
          }
  
          enumSubstanceClass::value enumSubstanceClass::
          _xsd_enumSubstanceClass_convert () const
          {
            ::xsd::cxx::tree::enum_comparator< char > c (_xsd_enumSubstanceClass_literals_);
            const value* i (::std::lower_bound (
                              _xsd_enumSubstanceClass_indexes_,
                              _xsd_enumSubstanceClass_indexes_ + 7,
                              *this,
                              c));
  
            if (i == _xsd_enumSubstanceClass_indexes_ + 7 || _xsd_enumSubstanceClass_literals_[*i] != *this)
            {
              throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this);
            }
  
            return *i;
          }
  
          const char* const enumSubstanceClass::
          _xsd_enumSubstanceClass_literals_[7] =
          {
            "Anesthetic",
            "Antibiotic",
            "WholeBlood",
            "Ion",
            "Opioid",
            "ReversalAgent",
            "Sedative"
          };
  
          const enumSubstanceClass::value enumSubstanceClass::
          _xsd_enumSubstanceClass_indexes_[7] =
          {
            ::mil::tatrc::physiology::datamodel::enumSubstanceClass::Anesthetic,
            ::mil::tatrc::physiology::datamodel::enumSubstanceClass::Antibiotic,
            ::mil::tatrc::physiology::datamodel::enumSubstanceClass::Ion,
            ::mil::tatrc::physiology::datamodel::enumSubstanceClass::Opioid,
            ::mil::tatrc::physiology::datamodel::enumSubstanceClass::ReversalAgent,
            ::mil::tatrc::physiology::datamodel::enumSubstanceClass::Sedative,
            ::mil::tatrc::physiology::datamodel::enumSubstanceClass::WholeBlood
          };
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, enumSubstanceClass >
          _xsd_enumSubstanceClass_type_factory_init (
            "enumSubstanceClass",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // SubstanceAerosolizationData
          //
  
          SubstanceAerosolizationData::
          SubstanceAerosolizationData ()
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            BronchioleModifier_ (this),
            InflammationCoefficient_ (this),
            ParticulateSizeDistribution_ (this)
          {
          }
  
          SubstanceAerosolizationData::
          SubstanceAerosolizationData (const BronchioleModifier_type& BronchioleModifier,
                                       const InflammationCoefficient_type& InflammationCoefficient,
                                       const ParticulateSizeDistribution_type& ParticulateSizeDistribution)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            BronchioleModifier_ (BronchioleModifier, this),
            InflammationCoefficient_ (InflammationCoefficient, this),
            ParticulateSizeDistribution_ (ParticulateSizeDistribution, this)
          {
          }
  
          SubstanceAerosolizationData::
          SubstanceAerosolizationData (::std::unique_ptr< BronchioleModifier_type > BronchioleModifier,
                                       ::std::unique_ptr< InflammationCoefficient_type > InflammationCoefficient,
                                       ::std::unique_ptr< ParticulateSizeDistribution_type > ParticulateSizeDistribution)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            BronchioleModifier_ (std::move (BronchioleModifier), this),
            InflammationCoefficient_ (std::move (InflammationCoefficient), this),
            ParticulateSizeDistribution_ (std::move (ParticulateSizeDistribution), this)
          {
          }
  
          SubstanceAerosolizationData::
          SubstanceAerosolizationData (const SubstanceAerosolizationData& x,
                                       ::xml_schema::flags f,
                                       ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (x, f, c),
            BronchioleModifier_ (x.BronchioleModifier_, f, this),
            InflammationCoefficient_ (x.InflammationCoefficient_, f, this),
            ParticulateSizeDistribution_ (x.ParticulateSizeDistribution_, f, this)
          {
          }
  
          SubstanceAerosolizationData::
          SubstanceAerosolizationData (const ::xercesc::DOMElement& e,
                                       ::xml_schema::flags f,
                                       ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (e, f | ::xml_schema::flags::base, c),
            BronchioleModifier_ (this),
            InflammationCoefficient_ (this),
            ParticulateSizeDistribution_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
              this->parse (p, f);
            }
          }
  
          void SubstanceAerosolizationData::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            this->::mil::tatrc::physiology::datamodel::ObjectData::parse (p, f);
  
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // BronchioleModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "BronchioleModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< BronchioleModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!BronchioleModifier_.present ())
                  {
                    ::std::unique_ptr< BronchioleModifier_type > r (
                      dynamic_cast< BronchioleModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->BronchioleModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // InflammationCoefficient
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "InflammationCoefficient",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< InflammationCoefficient_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!InflammationCoefficient_.present ())
                  {
                    ::std::unique_ptr< InflammationCoefficient_type > r (
                      dynamic_cast< InflammationCoefficient_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->InflammationCoefficient_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // ParticulateSizeDistribution
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "ParticulateSizeDistribution",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< ParticulateSizeDistribution_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!ParticulateSizeDistribution_.present ())
                  {
                    ::std::unique_ptr< ParticulateSizeDistribution_type > r (
                      dynamic_cast< ParticulateSizeDistribution_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->ParticulateSizeDistribution_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
  
            if (!BronchioleModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "BronchioleModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!InflammationCoefficient_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "InflammationCoefficient",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!ParticulateSizeDistribution_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "ParticulateSizeDistribution",
                "uri:/mil/tatrc/physiology/datamodel");
            }
          }
  
          SubstanceAerosolizationData* SubstanceAerosolizationData::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class SubstanceAerosolizationData (*this, f, c);
          }
  
          SubstanceAerosolizationData& SubstanceAerosolizationData::
          operator= (const SubstanceAerosolizationData& x)
          {
            if (this != &x)
            {
              static_cast< ::mil::tatrc::physiology::datamodel::ObjectData& > (*this) = x;
              this->BronchioleModifier_ = x.BronchioleModifier_;
              this->InflammationCoefficient_ = x.InflammationCoefficient_;
              this->ParticulateSizeDistribution_ = x.ParticulateSizeDistribution_;
            }
  
            return *this;
          }
  
          SubstanceAerosolizationData::
          ~SubstanceAerosolizationData ()
          {
          }
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, SubstanceAerosolizationData >
          _xsd_SubstanceAerosolizationData_type_factory_init (
            "SubstanceAerosolizationData",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // SubstancePharmacokineticsData
          //
  
          SubstancePharmacokineticsData::
          SubstancePharmacokineticsData ()
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            Physicochemicals_ (this),
            TissueKinetics_ (this)
          {
          }
  
          SubstancePharmacokineticsData::
          SubstancePharmacokineticsData (const SubstancePharmacokineticsData& x,
                                         ::xml_schema::flags f,
                                         ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (x, f, c),
            Physicochemicals_ (x.Physicochemicals_, f, this),
            TissueKinetics_ (x.TissueKinetics_, f, this)
          {
          }
  
          SubstancePharmacokineticsData::
          SubstancePharmacokineticsData (const ::xercesc::DOMElement& e,
                                         ::xml_schema::flags f,
                                         ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (e, f | ::xml_schema::flags::base, c),
            Physicochemicals_ (this),
            TissueKinetics_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
              this->parse (p, f);
            }
          }
  
          void SubstancePharmacokineticsData::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            this->::mil::tatrc::physiology::datamodel::ObjectData::parse (p, f);
  
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // Physicochemicals
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Physicochemicals",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Physicochemicals_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->Physicochemicals_)
                  {
                    ::std::unique_ptr< Physicochemicals_type > r (
                      dynamic_cast< Physicochemicals_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Physicochemicals_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // TissueKinetics
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "TissueKinetics",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< TissueKinetics_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  ::std::unique_ptr< TissueKinetics_type > r (
                    dynamic_cast< TissueKinetics_type* > (tmp.get ()));
  
                  if (r.get ())
                    tmp.release ();
                  else
                    throw ::xsd::cxx::tree::not_derived< char > ();
  
                  this->TissueKinetics_.push_back (::std::move (r));
                  continue;
                }
              }
  
              break;
            }
          }
  
          SubstancePharmacokineticsData* SubstancePharmacokineticsData::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class SubstancePharmacokineticsData (*this, f, c);
          }
  
          SubstancePharmacokineticsData& SubstancePharmacokineticsData::
          operator= (const SubstancePharmacokineticsData& x)
          {
            if (this != &x)
            {
              static_cast< ::mil::tatrc::physiology::datamodel::ObjectData& > (*this) = x;
              this->Physicochemicals_ = x.Physicochemicals_;
              this->TissueKinetics_ = x.TissueKinetics_;
            }
  
            return *this;
          }
  
          SubstancePharmacokineticsData::
          ~SubstancePharmacokineticsData ()
          {
          }
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, SubstancePharmacokineticsData >
          _xsd_SubstancePharmacokineticsData_type_factory_init (
            "SubstancePharmacokineticsData",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // SubstancePhysicochemicalData
          //
  
          SubstancePhysicochemicalData::
          SubstancePhysicochemicalData ()
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            AcidDissociationConstant_ (this),
            BindingProtein_ (this),
            BloodPlasmaRatio_ (this),
            FractionUnboundInPlasma_ (this),
            IonicState_ (this),
            LogP_ (this),
            HydrogenBondCount_ (this),
            PolarSurfaceArea_ (this)
          {
          }
  
          SubstancePhysicochemicalData::
          SubstancePhysicochemicalData (const BindingProtein_type& BindingProtein,
                                        const BloodPlasmaRatio_type& BloodPlasmaRatio,
                                        const FractionUnboundInPlasma_type& FractionUnboundInPlasma,
                                        const IonicState_type& IonicState,
                                        const LogP_type& LogP)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            AcidDissociationConstant_ (this),
            BindingProtein_ (BindingProtein, this),
            BloodPlasmaRatio_ (BloodPlasmaRatio, this),
            FractionUnboundInPlasma_ (FractionUnboundInPlasma, this),
            IonicState_ (IonicState, this),
            LogP_ (LogP, this),
            HydrogenBondCount_ (this),
            PolarSurfaceArea_ (this)
          {
          }
  
          SubstancePhysicochemicalData::
          SubstancePhysicochemicalData (const BindingProtein_type& BindingProtein,
                                        ::std::unique_ptr< BloodPlasmaRatio_type > BloodPlasmaRatio,
                                        ::std::unique_ptr< FractionUnboundInPlasma_type > FractionUnboundInPlasma,
                                        const IonicState_type& IonicState,
                                        ::std::unique_ptr< LogP_type > LogP)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            AcidDissociationConstant_ (this),
            BindingProtein_ (BindingProtein, this),
            BloodPlasmaRatio_ (std::move (BloodPlasmaRatio), this),
            FractionUnboundInPlasma_ (std::move (FractionUnboundInPlasma), this),
            IonicState_ (IonicState, this),
            LogP_ (std::move (LogP), this),
            HydrogenBondCount_ (this),
            PolarSurfaceArea_ (this)
          {
          }
  
          SubstancePhysicochemicalData::
          SubstancePhysicochemicalData (::std::unique_ptr< BindingProtein_type > BindingProtein,
                                        ::std::unique_ptr< BloodPlasmaRatio_type > BloodPlasmaRatio,
                                        ::std::unique_ptr< FractionUnboundInPlasma_type > FractionUnboundInPlasma,
                                        ::std::unique_ptr< IonicState_type > IonicState,
                                        ::std::unique_ptr< LogP_type > LogP)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            AcidDissociationConstant_ (this),
            BindingProtein_ (std::move (BindingProtein), this),
            BloodPlasmaRatio_ (std::move (BloodPlasmaRatio), this),
            FractionUnboundInPlasma_ (std::move (FractionUnboundInPlasma), this),
            IonicState_ (std::move (IonicState), this),
            LogP_ (std::move (LogP), this),
            HydrogenBondCount_ (this),
            PolarSurfaceArea_ (this)
          {
          }
  
          SubstancePhysicochemicalData::
          SubstancePhysicochemicalData (const SubstancePhysicochemicalData& x,
                                        ::xml_schema::flags f,
                                        ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (x, f, c),
            AcidDissociationConstant_ (x.AcidDissociationConstant_, f, this),
            BindingProtein_ (x.BindingProtein_, f, this),
            BloodPlasmaRatio_ (x.BloodPlasmaRatio_, f, this),
            FractionUnboundInPlasma_ (x.FractionUnboundInPlasma_, f, this),
            IonicState_ (x.IonicState_, f, this),
            LogP_ (x.LogP_, f, this),
            HydrogenBondCount_ (x.HydrogenBondCount_, f, this),
            PolarSurfaceArea_ (x.PolarSurfaceArea_, f, this)
          {
          }
  
          SubstancePhysicochemicalData::
          SubstancePhysicochemicalData (const ::xercesc::DOMElement& e,
                                        ::xml_schema::flags f,
                                        ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (e, f | ::xml_schema::flags::base, c),
            AcidDissociationConstant_ (this),
            BindingProtein_ (this),
            BloodPlasmaRatio_ (this),
            FractionUnboundInPlasma_ (this),
            IonicState_ (this),
            LogP_ (this),
            HydrogenBondCount_ (this),
            PolarSurfaceArea_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
              this->parse (p, f);
            }
          }
  
          void SubstancePhysicochemicalData::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            this->::mil::tatrc::physiology::datamodel::ObjectData::parse (p, f);
  
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // AcidDissociationConstant
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "AcidDissociationConstant",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< AcidDissociationConstant_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  ::std::unique_ptr< AcidDissociationConstant_type > r (
                    dynamic_cast< AcidDissociationConstant_type* > (tmp.get ()));
  
                  if (r.get ())
                    tmp.release ();
                  else
                    throw ::xsd::cxx::tree::not_derived< char > ();
  
                  this->AcidDissociationConstant_.push_back (::std::move (r));
                  continue;
                }
              }
  
              // BindingProtein
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "BindingProtein",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< BindingProtein_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!BindingProtein_.present ())
                  {
                    ::std::unique_ptr< BindingProtein_type > r (
                      dynamic_cast< BindingProtein_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->BindingProtein_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // BloodPlasmaRatio
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "BloodPlasmaRatio",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< BloodPlasmaRatio_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!BloodPlasmaRatio_.present ())
                  {
                    ::std::unique_ptr< BloodPlasmaRatio_type > r (
                      dynamic_cast< BloodPlasmaRatio_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->BloodPlasmaRatio_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // FractionUnboundInPlasma
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "FractionUnboundInPlasma",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< FractionUnboundInPlasma_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!FractionUnboundInPlasma_.present ())
                  {
                    ::std::unique_ptr< FractionUnboundInPlasma_type > r (
                      dynamic_cast< FractionUnboundInPlasma_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->FractionUnboundInPlasma_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // IonicState
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "IonicState",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< IonicState_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!IonicState_.present ())
                  {
                    ::std::unique_ptr< IonicState_type > r (
                      dynamic_cast< IonicState_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->IonicState_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // LogP
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "LogP",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< LogP_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!LogP_.present ())
                  {
                    ::std::unique_ptr< LogP_type > r (
                      dynamic_cast< LogP_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->LogP_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // HydrogenBondCount
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "HydrogenBondCount",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< HydrogenBondCount_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->HydrogenBondCount_)
                  {
                    ::std::unique_ptr< HydrogenBondCount_type > r (
                      dynamic_cast< HydrogenBondCount_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->HydrogenBondCount_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // PolarSurfaceArea
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "PolarSurfaceArea",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< PolarSurfaceArea_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->PolarSurfaceArea_)
                  {
                    ::std::unique_ptr< PolarSurfaceArea_type > r (
                      dynamic_cast< PolarSurfaceArea_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->PolarSurfaceArea_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
  
            if (!BindingProtein_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "BindingProtein",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!BloodPlasmaRatio_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "BloodPlasmaRatio",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!FractionUnboundInPlasma_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "FractionUnboundInPlasma",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!IonicState_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "IonicState",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!LogP_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "LogP",
                "uri:/mil/tatrc/physiology/datamodel");
            }
          }
  
          SubstancePhysicochemicalData* SubstancePhysicochemicalData::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class SubstancePhysicochemicalData (*this, f, c);
          }
  
          SubstancePhysicochemicalData& SubstancePhysicochemicalData::
          operator= (const SubstancePhysicochemicalData& x)
          {
            if (this != &x)
            {
              static_cast< ::mil::tatrc::physiology::datamodel::ObjectData& > (*this) = x;
              this->AcidDissociationConstant_ = x.AcidDissociationConstant_;
              this->BindingProtein_ = x.BindingProtein_;
              this->BloodPlasmaRatio_ = x.BloodPlasmaRatio_;
              this->FractionUnboundInPlasma_ = x.FractionUnboundInPlasma_;
              this->IonicState_ = x.IonicState_;
              this->LogP_ = x.LogP_;
              this->HydrogenBondCount_ = x.HydrogenBondCount_;
              this->PolarSurfaceArea_ = x.PolarSurfaceArea_;
            }
  
            return *this;
          }
  
          SubstancePhysicochemicalData::
          ~SubstancePhysicochemicalData ()
          {
          }
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, SubstancePhysicochemicalData >
          _xsd_SubstancePhysicochemicalData_type_factory_init (
            "SubstancePhysicochemicalData",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // SubstanceTissuePharmacokineticsData
          //
  
          SubstanceTissuePharmacokineticsData::
          SubstanceTissuePharmacokineticsData ()
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            Name_ (this),
            PartitionCoefficient_ (this)
          {
          }
  
          SubstanceTissuePharmacokineticsData::
          SubstanceTissuePharmacokineticsData (const Name_type& Name)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            Name_ (Name, this),
            PartitionCoefficient_ (this)
          {
          }
  
          SubstanceTissuePharmacokineticsData::
          SubstanceTissuePharmacokineticsData (::std::unique_ptr< Name_type > Name)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            Name_ (std::move (Name), this),
            PartitionCoefficient_ (this)
          {
          }
  
          SubstanceTissuePharmacokineticsData::
          SubstanceTissuePharmacokineticsData (const SubstanceTissuePharmacokineticsData& x,
                                               ::xml_schema::flags f,
                                               ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (x, f, c),
            Name_ (x.Name_, f, this),
            PartitionCoefficient_ (x.PartitionCoefficient_, f, this)
          {
          }
  
          SubstanceTissuePharmacokineticsData::
          SubstanceTissuePharmacokineticsData (const ::xercesc::DOMElement& e,
                                               ::xml_schema::flags f,
                                               ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (e, f | ::xml_schema::flags::base, c),
            Name_ (this),
            PartitionCoefficient_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
              this->parse (p, f);
            }
          }
  
          void SubstanceTissuePharmacokineticsData::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            this->::mil::tatrc::physiology::datamodel::ObjectData::parse (p, f);
  
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // Name
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Name",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Name_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!Name_.present ())
                  {
                    ::std::unique_ptr< Name_type > r (
                      dynamic_cast< Name_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Name_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // PartitionCoefficient
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "PartitionCoefficient",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< PartitionCoefficient_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->PartitionCoefficient_)
                  {
                    ::std::unique_ptr< PartitionCoefficient_type > r (
                      dynamic_cast< PartitionCoefficient_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->PartitionCoefficient_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
  
            if (!Name_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "Name",
                "uri:/mil/tatrc/physiology/datamodel");
            }
          }
  
          SubstanceTissuePharmacokineticsData* SubstanceTissuePharmacokineticsData::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class SubstanceTissuePharmacokineticsData (*this, f, c);
          }
  
          SubstanceTissuePharmacokineticsData& SubstanceTissuePharmacokineticsData::
          operator= (const SubstanceTissuePharmacokineticsData& x)
          {
            if (this != &x)
            {
              static_cast< ::mil::tatrc::physiology::datamodel::ObjectData& > (*this) = x;
              this->Name_ = x.Name_;
              this->PartitionCoefficient_ = x.PartitionCoefficient_;
            }
  
            return *this;
          }
  
          SubstanceTissuePharmacokineticsData::
          ~SubstanceTissuePharmacokineticsData ()
          {
          }
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, SubstanceTissuePharmacokineticsData >
          _xsd_SubstanceTissuePharmacokineticsData_type_factory_init (
            "SubstanceTissuePharmacokineticsData",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // SubstancePharmacodynamicsData
          //
  
          SubstancePharmacodynamicsData::
          SubstancePharmacodynamicsData ()
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            EffectSiteRateConstant_ (this),
            EMaxShapeParameter_ (this),
            AntibacterialEffect_ (this),
            Bronchodilation_ (this),
            CentralNervousModifier_ (this),
            DiastolicPressureModifier_ (this),
            FeverModifier_ (this),
            HeartRateModifier_ (this),
            HemorrhageModifier_ (this),
            NeuromuscularBlock_ (this),
            PainModifier_ (this),
            PupilReactivityModifier_ (this),
            PupilSizeModifier_ (this),
            RespirationRateModifier_ (this),
            Sedation_ (this),
            SystolicPressureModifier_ (this),
            TidalVolumeModifier_ (this),
            TubularPermeabilityModifier_ (this)
          {
          }
  
          SubstancePharmacodynamicsData::
          SubstancePharmacodynamicsData (const EffectSiteRateConstant_type& EffectSiteRateConstant,
                                         const EMaxShapeParameter_type& EMaxShapeParameter,
                                         const AntibacterialEffect_type& AntibacterialEffect,
                                         const Bronchodilation_type& Bronchodilation,
                                         const CentralNervousModifier_type& CentralNervousModifier,
                                         const DiastolicPressureModifier_type& DiastolicPressureModifier,
                                         const FeverModifier_type& FeverModifier,
                                         const HeartRateModifier_type& HeartRateModifier,
                                         const HemorrhageModifier_type& HemorrhageModifier,
                                         const NeuromuscularBlock_type& NeuromuscularBlock,
                                         const PainModifier_type& PainModifier,
                                         const PupilReactivityModifier_type& PupilReactivityModifier,
                                         const PupilSizeModifier_type& PupilSizeModifier,
                                         const RespirationRateModifier_type& RespirationRateModifier,
                                         const Sedation_type& Sedation,
                                         const SystolicPressureModifier_type& SystolicPressureModifier,
                                         const TidalVolumeModifier_type& TidalVolumeModifier,
                                         const TubularPermeabilityModifier_type& TubularPermeabilityModifier)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            EffectSiteRateConstant_ (EffectSiteRateConstant, this),
            EMaxShapeParameter_ (EMaxShapeParameter, this),
            AntibacterialEffect_ (AntibacterialEffect, this),
            Bronchodilation_ (Bronchodilation, this),
            CentralNervousModifier_ (CentralNervousModifier, this),
            DiastolicPressureModifier_ (DiastolicPressureModifier, this),
            FeverModifier_ (FeverModifier, this),
            HeartRateModifier_ (HeartRateModifier, this),
            HemorrhageModifier_ (HemorrhageModifier, this),
            NeuromuscularBlock_ (NeuromuscularBlock, this),
            PainModifier_ (PainModifier, this),
            PupilReactivityModifier_ (PupilReactivityModifier, this),
            PupilSizeModifier_ (PupilSizeModifier, this),
            RespirationRateModifier_ (RespirationRateModifier, this),
            Sedation_ (Sedation, this),
            SystolicPressureModifier_ (SystolicPressureModifier, this),
            TidalVolumeModifier_ (TidalVolumeModifier, this),
            TubularPermeabilityModifier_ (TubularPermeabilityModifier, this)
          {
          }
  
          SubstancePharmacodynamicsData::
          SubstancePharmacodynamicsData (::std::unique_ptr< EffectSiteRateConstant_type > EffectSiteRateConstant,
                                         ::std::unique_ptr< EMaxShapeParameter_type > EMaxShapeParameter,
                                         ::std::unique_ptr< AntibacterialEffect_type > AntibacterialEffect,
                                         ::std::unique_ptr< Bronchodilation_type > Bronchodilation,
                                         ::std::unique_ptr< CentralNervousModifier_type > CentralNervousModifier,
                                         ::std::unique_ptr< DiastolicPressureModifier_type > DiastolicPressureModifier,
                                         ::std::unique_ptr< FeverModifier_type > FeverModifier,
                                         ::std::unique_ptr< HeartRateModifier_type > HeartRateModifier,
                                         ::std::unique_ptr< HemorrhageModifier_type > HemorrhageModifier,
                                         ::std::unique_ptr< NeuromuscularBlock_type > NeuromuscularBlock,
                                         ::std::unique_ptr< PainModifier_type > PainModifier,
                                         ::std::unique_ptr< PupilReactivityModifier_type > PupilReactivityModifier,
                                         ::std::unique_ptr< PupilSizeModifier_type > PupilSizeModifier,
                                         ::std::unique_ptr< RespirationRateModifier_type > RespirationRateModifier,
                                         ::std::unique_ptr< Sedation_type > Sedation,
                                         ::std::unique_ptr< SystolicPressureModifier_type > SystolicPressureModifier,
                                         ::std::unique_ptr< TidalVolumeModifier_type > TidalVolumeModifier,
                                         ::std::unique_ptr< TubularPermeabilityModifier_type > TubularPermeabilityModifier)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            EffectSiteRateConstant_ (std::move (EffectSiteRateConstant), this),
            EMaxShapeParameter_ (std::move (EMaxShapeParameter), this),
            AntibacterialEffect_ (std::move (AntibacterialEffect), this),
            Bronchodilation_ (std::move (Bronchodilation), this),
            CentralNervousModifier_ (std::move (CentralNervousModifier), this),
            DiastolicPressureModifier_ (std::move (DiastolicPressureModifier), this),
            FeverModifier_ (std::move (FeverModifier), this),
            HeartRateModifier_ (std::move (HeartRateModifier), this),
            HemorrhageModifier_ (std::move (HemorrhageModifier), this),
            NeuromuscularBlock_ (std::move (NeuromuscularBlock), this),
            PainModifier_ (std::move (PainModifier), this),
            PupilReactivityModifier_ (std::move (PupilReactivityModifier), this),
            PupilSizeModifier_ (std::move (PupilSizeModifier), this),
            RespirationRateModifier_ (std::move (RespirationRateModifier), this),
            Sedation_ (std::move (Sedation), this),
            SystolicPressureModifier_ (std::move (SystolicPressureModifier), this),
            TidalVolumeModifier_ (std::move (TidalVolumeModifier), this),
            TubularPermeabilityModifier_ (std::move (TubularPermeabilityModifier), this)
          {
          }
  
          SubstancePharmacodynamicsData::
          SubstancePharmacodynamicsData (const SubstancePharmacodynamicsData& x,
                                         ::xml_schema::flags f,
                                         ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (x, f, c),
            EffectSiteRateConstant_ (x.EffectSiteRateConstant_, f, this),
            EMaxShapeParameter_ (x.EMaxShapeParameter_, f, this),
            AntibacterialEffect_ (x.AntibacterialEffect_, f, this),
            Bronchodilation_ (x.Bronchodilation_, f, this),
            CentralNervousModifier_ (x.CentralNervousModifier_, f, this),
            DiastolicPressureModifier_ (x.DiastolicPressureModifier_, f, this),
            FeverModifier_ (x.FeverModifier_, f, this),
            HeartRateModifier_ (x.HeartRateModifier_, f, this),
            HemorrhageModifier_ (x.HemorrhageModifier_, f, this),
            NeuromuscularBlock_ (x.NeuromuscularBlock_, f, this),
            PainModifier_ (x.PainModifier_, f, this),
            PupilReactivityModifier_ (x.PupilReactivityModifier_, f, this),
            PupilSizeModifier_ (x.PupilSizeModifier_, f, this),
            RespirationRateModifier_ (x.RespirationRateModifier_, f, this),
            Sedation_ (x.Sedation_, f, this),
            SystolicPressureModifier_ (x.SystolicPressureModifier_, f, this),
            TidalVolumeModifier_ (x.TidalVolumeModifier_, f, this),
            TubularPermeabilityModifier_ (x.TubularPermeabilityModifier_, f, this)
          {
          }
  
          SubstancePharmacodynamicsData::
          SubstancePharmacodynamicsData (const ::xercesc::DOMElement& e,
                                         ::xml_schema::flags f,
                                         ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (e, f | ::xml_schema::flags::base, c),
            EffectSiteRateConstant_ (this),
            EMaxShapeParameter_ (this),
            AntibacterialEffect_ (this),
            Bronchodilation_ (this),
            CentralNervousModifier_ (this),
            DiastolicPressureModifier_ (this),
            FeverModifier_ (this),
            HeartRateModifier_ (this),
            HemorrhageModifier_ (this),
            NeuromuscularBlock_ (this),
            PainModifier_ (this),
            PupilReactivityModifier_ (this),
            PupilSizeModifier_ (this),
            RespirationRateModifier_ (this),
            Sedation_ (this),
            SystolicPressureModifier_ (this),
            TidalVolumeModifier_ (this),
            TubularPermeabilityModifier_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
              this->parse (p, f);
            }
          }
  
          void SubstancePharmacodynamicsData::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            this->::mil::tatrc::physiology::datamodel::ObjectData::parse (p, f);
  
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // EffectSiteRateConstant
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "EffectSiteRateConstant",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< EffectSiteRateConstant_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!EffectSiteRateConstant_.present ())
                  {
                    ::std::unique_ptr< EffectSiteRateConstant_type > r (
                      dynamic_cast< EffectSiteRateConstant_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->EffectSiteRateConstant_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // EMaxShapeParameter
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "EMaxShapeParameter",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< EMaxShapeParameter_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!EMaxShapeParameter_.present ())
                  {
                    ::std::unique_ptr< EMaxShapeParameter_type > r (
                      dynamic_cast< EMaxShapeParameter_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->EMaxShapeParameter_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // AntibacterialEffect
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "AntibacterialEffect",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< AntibacterialEffect_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!AntibacterialEffect_.present ())
                  {
                    ::std::unique_ptr< AntibacterialEffect_type > r (
                      dynamic_cast< AntibacterialEffect_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->AntibacterialEffect_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // Bronchodilation
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Bronchodilation",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Bronchodilation_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!Bronchodilation_.present ())
                  {
                    ::std::unique_ptr< Bronchodilation_type > r (
                      dynamic_cast< Bronchodilation_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Bronchodilation_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // CentralNervousModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "CentralNervousModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< CentralNervousModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!CentralNervousModifier_.present ())
                  {
                    ::std::unique_ptr< CentralNervousModifier_type > r (
                      dynamic_cast< CentralNervousModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->CentralNervousModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // DiastolicPressureModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "DiastolicPressureModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< DiastolicPressureModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!DiastolicPressureModifier_.present ())
                  {
                    ::std::unique_ptr< DiastolicPressureModifier_type > r (
                      dynamic_cast< DiastolicPressureModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->DiastolicPressureModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // FeverModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "FeverModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< FeverModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!FeverModifier_.present ())
                  {
                    ::std::unique_ptr< FeverModifier_type > r (
                      dynamic_cast< FeverModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->FeverModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // HeartRateModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "HeartRateModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< HeartRateModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!HeartRateModifier_.present ())
                  {
                    ::std::unique_ptr< HeartRateModifier_type > r (
                      dynamic_cast< HeartRateModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->HeartRateModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // HemorrhageModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "HemorrhageModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< HemorrhageModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!HemorrhageModifier_.present ())
                  {
                    ::std::unique_ptr< HemorrhageModifier_type > r (
                      dynamic_cast< HemorrhageModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->HemorrhageModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // NeuromuscularBlock
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "NeuromuscularBlock",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< NeuromuscularBlock_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!NeuromuscularBlock_.present ())
                  {
                    ::std::unique_ptr< NeuromuscularBlock_type > r (
                      dynamic_cast< NeuromuscularBlock_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->NeuromuscularBlock_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // PainModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "PainModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< PainModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!PainModifier_.present ())
                  {
                    ::std::unique_ptr< PainModifier_type > r (
                      dynamic_cast< PainModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->PainModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // PupilReactivityModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "PupilReactivityModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< PupilReactivityModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!PupilReactivityModifier_.present ())
                  {
                    ::std::unique_ptr< PupilReactivityModifier_type > r (
                      dynamic_cast< PupilReactivityModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->PupilReactivityModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // PupilSizeModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "PupilSizeModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< PupilSizeModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!PupilSizeModifier_.present ())
                  {
                    ::std::unique_ptr< PupilSizeModifier_type > r (
                      dynamic_cast< PupilSizeModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->PupilSizeModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // RespirationRateModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "RespirationRateModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< RespirationRateModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!RespirationRateModifier_.present ())
                  {
                    ::std::unique_ptr< RespirationRateModifier_type > r (
                      dynamic_cast< RespirationRateModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->RespirationRateModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // Sedation
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Sedation",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Sedation_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!Sedation_.present ())
                  {
                    ::std::unique_ptr< Sedation_type > r (
                      dynamic_cast< Sedation_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Sedation_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // SystolicPressureModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "SystolicPressureModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< SystolicPressureModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!SystolicPressureModifier_.present ())
                  {
                    ::std::unique_ptr< SystolicPressureModifier_type > r (
                      dynamic_cast< SystolicPressureModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->SystolicPressureModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // TidalVolumeModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "TidalVolumeModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< TidalVolumeModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!TidalVolumeModifier_.present ())
                  {
                    ::std::unique_ptr< TidalVolumeModifier_type > r (
                      dynamic_cast< TidalVolumeModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->TidalVolumeModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // TubularPermeabilityModifier
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "TubularPermeabilityModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< TubularPermeabilityModifier_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!TubularPermeabilityModifier_.present ())
                  {
                    ::std::unique_ptr< TubularPermeabilityModifier_type > r (
                      dynamic_cast< TubularPermeabilityModifier_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->TubularPermeabilityModifier_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
  
            if (!EffectSiteRateConstant_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "EffectSiteRateConstant",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!EMaxShapeParameter_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "EMaxShapeParameter",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!AntibacterialEffect_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "AntibacterialEffect",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!Bronchodilation_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "Bronchodilation",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!CentralNervousModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "CentralNervousModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!DiastolicPressureModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "DiastolicPressureModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!FeverModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "FeverModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!HeartRateModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "HeartRateModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!HemorrhageModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "HemorrhageModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!NeuromuscularBlock_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "NeuromuscularBlock",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!PainModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "PainModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!PupilReactivityModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "PupilReactivityModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!PupilSizeModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "PupilSizeModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!RespirationRateModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "RespirationRateModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!Sedation_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "Sedation",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!SystolicPressureModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "SystolicPressureModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!TidalVolumeModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "TidalVolumeModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!TubularPermeabilityModifier_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "TubularPermeabilityModifier",
                "uri:/mil/tatrc/physiology/datamodel");
            }
          }
  
          SubstancePharmacodynamicsData* SubstancePharmacodynamicsData::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class SubstancePharmacodynamicsData (*this, f, c);
          }
  
          SubstancePharmacodynamicsData& SubstancePharmacodynamicsData::
          operator= (const SubstancePharmacodynamicsData& x)
          {
            if (this != &x)
            {
              static_cast< ::mil::tatrc::physiology::datamodel::ObjectData& > (*this) = x;
              this->EffectSiteRateConstant_ = x.EffectSiteRateConstant_;
              this->EMaxShapeParameter_ = x.EMaxShapeParameter_;
              this->AntibacterialEffect_ = x.AntibacterialEffect_;
              this->Bronchodilation_ = x.Bronchodilation_;
              this->CentralNervousModifier_ = x.CentralNervousModifier_;
              this->DiastolicPressureModifier_ = x.DiastolicPressureModifier_;
              this->FeverModifier_ = x.FeverModifier_;
              this->HeartRateModifier_ = x.HeartRateModifier_;
              this->HemorrhageModifier_ = x.HemorrhageModifier_;
              this->NeuromuscularBlock_ = x.NeuromuscularBlock_;
              this->PainModifier_ = x.PainModifier_;
              this->PupilReactivityModifier_ = x.PupilReactivityModifier_;
              this->PupilSizeModifier_ = x.PupilSizeModifier_;
              this->RespirationRateModifier_ = x.RespirationRateModifier_;
              this->Sedation_ = x.Sedation_;
              this->SystolicPressureModifier_ = x.SystolicPressureModifier_;
              this->TidalVolumeModifier_ = x.TidalVolumeModifier_;
              this->TubularPermeabilityModifier_ = x.TubularPermeabilityModifier_;
            }
  
            return *this;
          }
  
          SubstancePharmacodynamicsData::
          ~SubstancePharmacodynamicsData ()
          {
          }
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, SubstancePharmacodynamicsData >
          _xsd_SubstancePharmacodynamicsData_type_factory_init (
            "SubstancePharmacodynamicsData",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // SubstanceClearanceData
          //
  
          SubstanceClearanceData::
          SubstanceClearanceData ()
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            Systemic_ (this),
            RenalDynamics_ (this),
            CellRegulation_ (this)
          {
          }
  
          SubstanceClearanceData::
          SubstanceClearanceData (const SubstanceClearanceData& x,
                                  ::xml_schema::flags f,
                                  ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (x, f, c),
            Systemic_ (x.Systemic_, f, this),
            RenalDynamics_ (x.RenalDynamics_, f, this),
            CellRegulation_ (x.CellRegulation_, f, this)
          {
          }
  
          SubstanceClearanceData::
          SubstanceClearanceData (const ::xercesc::DOMElement& e,
                                  ::xml_schema::flags f,
                                  ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (e, f | ::xml_schema::flags::base, c),
            Systemic_ (this),
            RenalDynamics_ (this),
            CellRegulation_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
              this->parse (p, f);
            }
          }
  
          void SubstanceClearanceData::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            this->::mil::tatrc::physiology::datamodel::ObjectData::parse (p, f);
  
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // Systemic
              //
              if (n.name () == "Systemic" && n.namespace_ () == "uri:/mil/tatrc/physiology/datamodel")
              {
                ::std::unique_ptr< Systemic_type > r (
                  Systemic_traits::create (i, f, this));
  
                if (!this->Systemic_)
                {
                  this->Systemic_.set (::std::move (r));
                  continue;
                }
              }
  
              // RenalDynamics
              //
              if (n.name () == "RenalDynamics" && n.namespace_ () == "uri:/mil/tatrc/physiology/datamodel")
              {
                ::std::unique_ptr< RenalDynamics_type > r (
                  RenalDynamics_traits::create (i, f, this));
  
                if (!this->RenalDynamics_)
                {
                  this->RenalDynamics_.set (::std::move (r));
                  continue;
                }
              }
  
              // CellRegulation
              //
              if (n.name () == "CellRegulation" && n.namespace_ () == "uri:/mil/tatrc/physiology/datamodel")
              {
                ::std::unique_ptr< CellRegulation_type > r (
                  CellRegulation_traits::create (i, f, this));
  
                if (!this->CellRegulation_)
                {
                  this->CellRegulation_.set (::std::move (r));
                  continue;
                }
              }
  
              break;
            }
          }
  
          SubstanceClearanceData* SubstanceClearanceData::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class SubstanceClearanceData (*this, f, c);
          }
  
          SubstanceClearanceData& SubstanceClearanceData::
          operator= (const SubstanceClearanceData& x)
          {
            if (this != &x)
            {
              static_cast< ::mil::tatrc::physiology::datamodel::ObjectData& > (*this) = x;
              this->Systemic_ = x.Systemic_;
              this->RenalDynamics_ = x.RenalDynamics_;
              this->CellRegulation_ = x.CellRegulation_;
            }
  
            return *this;
          }
  
          SubstanceClearanceData::
          ~SubstanceClearanceData ()
          {
          }
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, SubstanceClearanceData >
          _xsd_SubstanceClearanceData_type_factory_init (
            "SubstanceClearanceData",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // SubstanceData
          //
  
          SubstanceData::
          SubstanceData ()
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            Name_ (this),
            Classification_ (this),
            Density_ (this),
            MolarMass_ (this),
            State_ (this),
            MaximumDiffusionFlux_ (this),
            MichaelisCoefficient_ (this),
            MembraneResistance_ (this),
            Aerosolization_ (this),
            AreaUnderCurve_ (this),
            BloodConcentration_ (this),
            EffectSiteConcentration_ (this),
            MassInBody_ (this),
            MassInBlood_ (this),
            MassInTissue_ (this),
            PlasmaConcentration_ (this),
            SystemicMassCleared_ (this),
            TissueConcentration_ (this),
            AlveolarTransfer_ (this),
            DiffusingCapacity_ (this),
            EndTidalFraction_ (this),
            EndTidalPressure_ (this),
            RelativeDiffusionCoefficient_ (this),
            SolubilityCoefficient_ (this),
            Clearance_ (this),
            Pharmacokinetics_ (this),
            Pharmacodynamics_ (this)
          {
          }
  
          SubstanceData::
          SubstanceData (const Name_type& Name)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            Name_ (Name, this),
            Classification_ (this),
            Density_ (this),
            MolarMass_ (this),
            State_ (this),
            MaximumDiffusionFlux_ (this),
            MichaelisCoefficient_ (this),
            MembraneResistance_ (this),
            Aerosolization_ (this),
            AreaUnderCurve_ (this),
            BloodConcentration_ (this),
            EffectSiteConcentration_ (this),
            MassInBody_ (this),
            MassInBlood_ (this),
            MassInTissue_ (this),
            PlasmaConcentration_ (this),
            SystemicMassCleared_ (this),
            TissueConcentration_ (this),
            AlveolarTransfer_ (this),
            DiffusingCapacity_ (this),
            EndTidalFraction_ (this),
            EndTidalPressure_ (this),
            RelativeDiffusionCoefficient_ (this),
            SolubilityCoefficient_ (this),
            Clearance_ (this),
            Pharmacokinetics_ (this),
            Pharmacodynamics_ (this)
          {
          }
  
          SubstanceData::
          SubstanceData (::std::unique_ptr< Name_type > Name)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            Name_ (std::move (Name), this),
            Classification_ (this),
            Density_ (this),
            MolarMass_ (this),
            State_ (this),
            MaximumDiffusionFlux_ (this),
            MichaelisCoefficient_ (this),
            MembraneResistance_ (this),
            Aerosolization_ (this),
            AreaUnderCurve_ (this),
            BloodConcentration_ (this),
            EffectSiteConcentration_ (this),
            MassInBody_ (this),
            MassInBlood_ (this),
            MassInTissue_ (this),
            PlasmaConcentration_ (this),
            SystemicMassCleared_ (this),
            TissueConcentration_ (this),
            AlveolarTransfer_ (this),
            DiffusingCapacity_ (this),
            EndTidalFraction_ (this),
            EndTidalPressure_ (this),
            RelativeDiffusionCoefficient_ (this),
            SolubilityCoefficient_ (this),
            Clearance_ (this),
            Pharmacokinetics_ (this),
            Pharmacodynamics_ (this)
          {
          }
  
          SubstanceData::
          SubstanceData (const SubstanceData& x,
                         ::xml_schema::flags f,
                         ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (x, f, c),
            Name_ (x.Name_, f, this),
            Classification_ (x.Classification_, f, this),
            Density_ (x.Density_, f, this),
            MolarMass_ (x.MolarMass_, f, this),
            State_ (x.State_, f, this),
            MaximumDiffusionFlux_ (x.MaximumDiffusionFlux_, f, this),
            MichaelisCoefficient_ (x.MichaelisCoefficient_, f, this),
            MembraneResistance_ (x.MembraneResistance_, f, this),
            Aerosolization_ (x.Aerosolization_, f, this),
            AreaUnderCurve_ (x.AreaUnderCurve_, f, this),
            BloodConcentration_ (x.BloodConcentration_, f, this),
            EffectSiteConcentration_ (x.EffectSiteConcentration_, f, this),
            MassInBody_ (x.MassInBody_, f, this),
            MassInBlood_ (x.MassInBlood_, f, this),
            MassInTissue_ (x.MassInTissue_, f, this),
            PlasmaConcentration_ (x.PlasmaConcentration_, f, this),
            SystemicMassCleared_ (x.SystemicMassCleared_, f, this),
            TissueConcentration_ (x.TissueConcentration_, f, this),
            AlveolarTransfer_ (x.AlveolarTransfer_, f, this),
            DiffusingCapacity_ (x.DiffusingCapacity_, f, this),
            EndTidalFraction_ (x.EndTidalFraction_, f, this),
            EndTidalPressure_ (x.EndTidalPressure_, f, this),
            RelativeDiffusionCoefficient_ (x.RelativeDiffusionCoefficient_, f, this),
            SolubilityCoefficient_ (x.SolubilityCoefficient_, f, this),
            Clearance_ (x.Clearance_, f, this),
            Pharmacokinetics_ (x.Pharmacokinetics_, f, this),
            Pharmacodynamics_ (x.Pharmacodynamics_, f, this)
          {
          }
  
          SubstanceData::
          SubstanceData (const ::xercesc::DOMElement& e,
                         ::xml_schema::flags f,
                         ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (e, f | ::xml_schema::flags::base, c),
            Name_ (this),
            Classification_ (this),
            Density_ (this),
            MolarMass_ (this),
            State_ (this),
            MaximumDiffusionFlux_ (this),
            MichaelisCoefficient_ (this),
            MembraneResistance_ (this),
            Aerosolization_ (this),
            AreaUnderCurve_ (this),
            BloodConcentration_ (this),
            EffectSiteConcentration_ (this),
            MassInBody_ (this),
            MassInBlood_ (this),
            MassInTissue_ (this),
            PlasmaConcentration_ (this),
            SystemicMassCleared_ (this),
            TissueConcentration_ (this),
            AlveolarTransfer_ (this),
            DiffusingCapacity_ (this),
            EndTidalFraction_ (this),
            EndTidalPressure_ (this),
            RelativeDiffusionCoefficient_ (this),
            SolubilityCoefficient_ (this),
            Clearance_ (this),
            Pharmacokinetics_ (this),
            Pharmacodynamics_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
              this->parse (p, f);
            }
          }
  
          void SubstanceData::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            this->::mil::tatrc::physiology::datamodel::ObjectData::parse (p, f);
  
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // Name
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Name",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Name_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!Name_.present ())
                  {
                    ::std::unique_ptr< Name_type > r (
                      dynamic_cast< Name_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Name_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // Classification
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Classification",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Classification_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->Classification_)
                  {
                    ::std::unique_ptr< Classification_type > r (
                      dynamic_cast< Classification_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Classification_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // Density
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Density",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Density_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->Density_)
                  {
                    ::std::unique_ptr< Density_type > r (
                      dynamic_cast< Density_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Density_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // MolarMass
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "MolarMass",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< MolarMass_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->MolarMass_)
                  {
                    ::std::unique_ptr< MolarMass_type > r (
                      dynamic_cast< MolarMass_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->MolarMass_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // State
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "State",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< State_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->State_)
                  {
                    ::std::unique_ptr< State_type > r (
                      dynamic_cast< State_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->State_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // MaximumDiffusionFlux
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "MaximumDiffusionFlux",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< MaximumDiffusionFlux_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->MaximumDiffusionFlux_)
                  {
                    ::std::unique_ptr< MaximumDiffusionFlux_type > r (
                      dynamic_cast< MaximumDiffusionFlux_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->MaximumDiffusionFlux_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // MichaelisCoefficient
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "MichaelisCoefficient",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< MichaelisCoefficient_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->MichaelisCoefficient_)
                  {
                    ::std::unique_ptr< MichaelisCoefficient_type > r (
                      dynamic_cast< MichaelisCoefficient_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->MichaelisCoefficient_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // MembraneResistance
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "MembraneResistance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< MembraneResistance_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->MembraneResistance_)
                  {
                    ::std::unique_ptr< MembraneResistance_type > r (
                      dynamic_cast< MembraneResistance_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->MembraneResistance_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // Aerosolization
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Aerosolization",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Aerosolization_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->Aerosolization_)
                  {
                    ::std::unique_ptr< Aerosolization_type > r (
                      dynamic_cast< Aerosolization_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Aerosolization_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // AreaUnderCurve
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "AreaUnderCurve",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< AreaUnderCurve_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->AreaUnderCurve_)
                  {
                    ::std::unique_ptr< AreaUnderCurve_type > r (
                      dynamic_cast< AreaUnderCurve_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->AreaUnderCurve_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // BloodConcentration
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "BloodConcentration",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< BloodConcentration_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->BloodConcentration_)
                  {
                    ::std::unique_ptr< BloodConcentration_type > r (
                      dynamic_cast< BloodConcentration_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->BloodConcentration_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // EffectSiteConcentration
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "EffectSiteConcentration",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< EffectSiteConcentration_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->EffectSiteConcentration_)
                  {
                    ::std::unique_ptr< EffectSiteConcentration_type > r (
                      dynamic_cast< EffectSiteConcentration_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->EffectSiteConcentration_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // MassInBody
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "MassInBody",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< MassInBody_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->MassInBody_)
                  {
                    ::std::unique_ptr< MassInBody_type > r (
                      dynamic_cast< MassInBody_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->MassInBody_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // MassInBlood
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "MassInBlood",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< MassInBlood_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->MassInBlood_)
                  {
                    ::std::unique_ptr< MassInBlood_type > r (
                      dynamic_cast< MassInBlood_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->MassInBlood_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // MassInTissue
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "MassInTissue",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< MassInTissue_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->MassInTissue_)
                  {
                    ::std::unique_ptr< MassInTissue_type > r (
                      dynamic_cast< MassInTissue_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->MassInTissue_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // PlasmaConcentration
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "PlasmaConcentration",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< PlasmaConcentration_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->PlasmaConcentration_)
                  {
                    ::std::unique_ptr< PlasmaConcentration_type > r (
                      dynamic_cast< PlasmaConcentration_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->PlasmaConcentration_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // SystemicMassCleared
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "SystemicMassCleared",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< SystemicMassCleared_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->SystemicMassCleared_)
                  {
                    ::std::unique_ptr< SystemicMassCleared_type > r (
                      dynamic_cast< SystemicMassCleared_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->SystemicMassCleared_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // TissueConcentration
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "TissueConcentration",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< TissueConcentration_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->TissueConcentration_)
                  {
                    ::std::unique_ptr< TissueConcentration_type > r (
                      dynamic_cast< TissueConcentration_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->TissueConcentration_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // AlveolarTransfer
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "AlveolarTransfer",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< AlveolarTransfer_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->AlveolarTransfer_)
                  {
                    ::std::unique_ptr< AlveolarTransfer_type > r (
                      dynamic_cast< AlveolarTransfer_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->AlveolarTransfer_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // DiffusingCapacity
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "DiffusingCapacity",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< DiffusingCapacity_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->DiffusingCapacity_)
                  {
                    ::std::unique_ptr< DiffusingCapacity_type > r (
                      dynamic_cast< DiffusingCapacity_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->DiffusingCapacity_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // EndTidalFraction
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "EndTidalFraction",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< EndTidalFraction_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->EndTidalFraction_)
                  {
                    ::std::unique_ptr< EndTidalFraction_type > r (
                      dynamic_cast< EndTidalFraction_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->EndTidalFraction_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // EndTidalPressure
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "EndTidalPressure",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< EndTidalPressure_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->EndTidalPressure_)
                  {
                    ::std::unique_ptr< EndTidalPressure_type > r (
                      dynamic_cast< EndTidalPressure_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->EndTidalPressure_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // RelativeDiffusionCoefficient
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "RelativeDiffusionCoefficient",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< RelativeDiffusionCoefficient_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->RelativeDiffusionCoefficient_)
                  {
                    ::std::unique_ptr< RelativeDiffusionCoefficient_type > r (
                      dynamic_cast< RelativeDiffusionCoefficient_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->RelativeDiffusionCoefficient_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // SolubilityCoefficient
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "SolubilityCoefficient",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< SolubilityCoefficient_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->SolubilityCoefficient_)
                  {
                    ::std::unique_ptr< SolubilityCoefficient_type > r (
                      dynamic_cast< SolubilityCoefficient_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->SolubilityCoefficient_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // Clearance
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Clearance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Clearance_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->Clearance_)
                  {
                    ::std::unique_ptr< Clearance_type > r (
                      dynamic_cast< Clearance_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Clearance_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // Pharmacokinetics
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Pharmacokinetics",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Pharmacokinetics_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->Pharmacokinetics_)
                  {
                    ::std::unique_ptr< Pharmacokinetics_type > r (
                      dynamic_cast< Pharmacokinetics_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Pharmacokinetics_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // Pharmacodynamics
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Pharmacodynamics",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Pharmacodynamics_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->Pharmacodynamics_)
                  {
                    ::std::unique_ptr< Pharmacodynamics_type > r (
                      dynamic_cast< Pharmacodynamics_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Pharmacodynamics_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
  
            if (!Name_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "Name",
                "uri:/mil/tatrc/physiology/datamodel");
            }
          }
  
          SubstanceData* SubstanceData::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class SubstanceData (*this, f, c);
          }
  
          SubstanceData& SubstanceData::
          operator= (const SubstanceData& x)
          {
            if (this != &x)
            {
              static_cast< ::mil::tatrc::physiology::datamodel::ObjectData& > (*this) = x;
              this->Name_ = x.Name_;
              this->Classification_ = x.Classification_;
              this->Density_ = x.Density_;
              this->MolarMass_ = x.MolarMass_;
              this->State_ = x.State_;
              this->MaximumDiffusionFlux_ = x.MaximumDiffusionFlux_;
              this->MichaelisCoefficient_ = x.MichaelisCoefficient_;
              this->MembraneResistance_ = x.MembraneResistance_;
              this->Aerosolization_ = x.Aerosolization_;
              this->AreaUnderCurve_ = x.AreaUnderCurve_;
              this->BloodConcentration_ = x.BloodConcentration_;
              this->EffectSiteConcentration_ = x.EffectSiteConcentration_;
              this->MassInBody_ = x.MassInBody_;
              this->MassInBlood_ = x.MassInBlood_;
              this->MassInTissue_ = x.MassInTissue_;
              this->PlasmaConcentration_ = x.PlasmaConcentration_;
              this->SystemicMassCleared_ = x.SystemicMassCleared_;
              this->TissueConcentration_ = x.TissueConcentration_;
              this->AlveolarTransfer_ = x.AlveolarTransfer_;
              this->DiffusingCapacity_ = x.DiffusingCapacity_;
              this->EndTidalFraction_ = x.EndTidalFraction_;
              this->EndTidalPressure_ = x.EndTidalPressure_;
              this->RelativeDiffusionCoefficient_ = x.RelativeDiffusionCoefficient_;
              this->SolubilityCoefficient_ = x.SolubilityCoefficient_;
              this->Clearance_ = x.Clearance_;
              this->Pharmacokinetics_ = x.Pharmacokinetics_;
              this->Pharmacodynamics_ = x.Pharmacodynamics_;
            }
  
            return *this;
          }
  
          SubstanceData::
          ~SubstanceData ()
          {
          }
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, SubstanceData >
          _xsd_SubstanceData_type_factory_init (
            "SubstanceData",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // SubstanceCompoundData
          //
  
          SubstanceCompoundData::
          SubstanceCompoundData ()
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            Name_ (this),
            Classification_ (this),
            BloodRHFactor_ (this),
            Component_ (this)
          {
          }
  
          SubstanceCompoundData::
          SubstanceCompoundData (const Name_type& Name)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            Name_ (Name, this),
            Classification_ (this),
            BloodRHFactor_ (this),
            Component_ (this)
          {
          }
  
          SubstanceCompoundData::
          SubstanceCompoundData (::std::unique_ptr< Name_type > Name)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            Name_ (std::move (Name), this),
            Classification_ (this),
            BloodRHFactor_ (this),
            Component_ (this)
          {
          }
  
          SubstanceCompoundData::
          SubstanceCompoundData (const SubstanceCompoundData& x,
                                 ::xml_schema::flags f,
                                 ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (x, f, c),
            Name_ (x.Name_, f, this),
            Classification_ (x.Classification_, f, this),
            BloodRHFactor_ (x.BloodRHFactor_, f, this),
            Component_ (x.Component_, f, this)
          {
          }
  
          SubstanceCompoundData::
          SubstanceCompoundData (const ::xercesc::DOMElement& e,
                                 ::xml_schema::flags f,
                                 ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (e, f | ::xml_schema::flags::base, c),
            Name_ (this),
            Classification_ (this),
            BloodRHFactor_ (this),
            Component_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
              this->parse (p, f);
            }
          }
  
          void SubstanceCompoundData::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            this->::mil::tatrc::physiology::datamodel::ObjectData::parse (p, f);
  
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // Name
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Name",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Name_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!Name_.present ())
                  {
                    ::std::unique_ptr< Name_type > r (
                      dynamic_cast< Name_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Name_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // Classification
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Classification",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Classification_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->Classification_)
                  {
                    ::std::unique_ptr< Classification_type > r (
                      dynamic_cast< Classification_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Classification_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // BloodRHFactor
              //
              if (n.name () == "BloodRHFactor" && n.namespace_ () == "uri:/mil/tatrc/physiology/datamodel")
              {
                if (!this->BloodRHFactor_)
                {
                  this->BloodRHFactor_.set (BloodRHFactor_traits::create (i, f, this));
                  continue;
                }
              }
  
              // Component
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Component",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Component_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  ::std::unique_ptr< Component_type > r (
                    dynamic_cast< Component_type* > (tmp.get ()));
  
                  if (r.get ())
                    tmp.release ();
                  else
                    throw ::xsd::cxx::tree::not_derived< char > ();
  
                  this->Component_.push_back (::std::move (r));
                  continue;
                }
              }
  
              break;
            }
  
            if (!Name_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "Name",
                "uri:/mil/tatrc/physiology/datamodel");
            }
          }
  
          SubstanceCompoundData* SubstanceCompoundData::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class SubstanceCompoundData (*this, f, c);
          }
  
          SubstanceCompoundData& SubstanceCompoundData::
          operator= (const SubstanceCompoundData& x)
          {
            if (this != &x)
            {
              static_cast< ::mil::tatrc::physiology::datamodel::ObjectData& > (*this) = x;
              this->Name_ = x.Name_;
              this->Classification_ = x.Classification_;
              this->BloodRHFactor_ = x.BloodRHFactor_;
              this->Component_ = x.Component_;
            }
  
            return *this;
          }
  
          SubstanceCompoundData::
          ~SubstanceCompoundData ()
          {
          }
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, SubstanceCompoundData >
          _xsd_SubstanceCompoundData_type_factory_init (
            "SubstanceCompoundData",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // SubstanceFractionData
          //
  
          SubstanceFractionData::
          SubstanceFractionData ()
          : ::xml_schema::type (),
            FractionAmount_ (this),
            Name_ (this)
          {
          }
  
          SubstanceFractionData::
          SubstanceFractionData (const FractionAmount_type& FractionAmount,
                                 const Name_type& Name)
          : ::xml_schema::type (),
            FractionAmount_ (FractionAmount, this),
            Name_ (Name, this)
          {
          }
  
          SubstanceFractionData::
          SubstanceFractionData (::std::unique_ptr< FractionAmount_type > FractionAmount,
                                 const Name_type& Name)
          : ::xml_schema::type (),
            FractionAmount_ (std::move (FractionAmount), this),
            Name_ (Name, this)
          {
          }
  
          SubstanceFractionData::
          SubstanceFractionData (const SubstanceFractionData& x,
                                 ::xml_schema::flags f,
                                 ::xml_schema::container* c)
          : ::xml_schema::type (x, f, c),
            FractionAmount_ (x.FractionAmount_, f, this),
            Name_ (x.Name_, f, this)
          {
          }
  
          SubstanceFractionData::
          SubstanceFractionData (const ::xercesc::DOMElement& e,
                                 ::xml_schema::flags f,
                                 ::xml_schema::container* c)
          : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
            FractionAmount_ (this),
            Name_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
              this->parse (p, f);
            }
          }
  
          void SubstanceFractionData::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // FractionAmount
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "FractionAmount",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< FractionAmount_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!FractionAmount_.present ())
                  {
                    ::std::unique_ptr< FractionAmount_type > r (
                      dynamic_cast< FractionAmount_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->FractionAmount_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
  
            if (!FractionAmount_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "FractionAmount",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            while (p.more_attributes ())
            {
              const ::xercesc::DOMAttr& i (p.next_attribute ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              if (n.name () == "Name" && n.namespace_ ().empty ())
              {
                this->Name_.set (Name_traits::create (i, f, this));
                continue;
              }
            }
  
            if (!Name_.present ())
            {
              throw ::xsd::cxx::tree::expected_attribute< char > (
                "Name",
                "");
            }
          }
  
          SubstanceFractionData* SubstanceFractionData::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class SubstanceFractionData (*this, f, c);
          }
  
          SubstanceFractionData& SubstanceFractionData::
          operator= (const SubstanceFractionData& x)
          {
            if (this != &x)
            {
              static_cast< ::xml_schema::type& > (*this) = x;
              this->FractionAmount_ = x.FractionAmount_;
              this->Name_ = x.Name_;
            }
  
            return *this;
          }
  
          SubstanceFractionData::
          ~SubstanceFractionData ()
          {
          }
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, SubstanceFractionData >
          _xsd_SubstanceFractionData_type_factory_init (
            "SubstanceFractionData",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // SubstanceConcentrationData
          //
  
          SubstanceConcentrationData::
          SubstanceConcentrationData ()
          : ::xml_schema::type (),
            Concentration_ (this),
            Name_ (this)
          {
          }
  
          SubstanceConcentrationData::
          SubstanceConcentrationData (const Concentration_type& Concentration,
                                      const Name_type& Name)
          : ::xml_schema::type (),
            Concentration_ (Concentration, this),
            Name_ (Name, this)
          {
          }
  
          SubstanceConcentrationData::
          SubstanceConcentrationData (::std::unique_ptr< Concentration_type > Concentration,
                                      const Name_type& Name)
          : ::xml_schema::type (),
            Concentration_ (std::move (Concentration), this),
            Name_ (Name, this)
          {
          }
  
          SubstanceConcentrationData::
          SubstanceConcentrationData (const SubstanceConcentrationData& x,
                                      ::xml_schema::flags f,
                                      ::xml_schema::container* c)
          : ::xml_schema::type (x, f, c),
            Concentration_ (x.Concentration_, f, this),
            Name_ (x.Name_, f, this)
          {
          }
  
          SubstanceConcentrationData::
          SubstanceConcentrationData (const ::xercesc::DOMElement& e,
                                      ::xml_schema::flags f,
                                      ::xml_schema::container* c)
          : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
            Concentration_ (this),
            Name_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
              this->parse (p, f);
            }
          }
  
          void SubstanceConcentrationData::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // Concentration
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Concentration",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Concentration_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!Concentration_.present ())
                  {
                    ::std::unique_ptr< Concentration_type > r (
                      dynamic_cast< Concentration_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Concentration_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
  
            if (!Concentration_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "Concentration",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            while (p.more_attributes ())
            {
              const ::xercesc::DOMAttr& i (p.next_attribute ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              if (n.name () == "Name" && n.namespace_ ().empty ())
              {
                this->Name_.set (Name_traits::create (i, f, this));
                continue;
              }
            }
  
            if (!Name_.present ())
            {
              throw ::xsd::cxx::tree::expected_attribute< char > (
                "Name",
                "");
            }
          }
  
          SubstanceConcentrationData* SubstanceConcentrationData::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class SubstanceConcentrationData (*this, f, c);
          }
  
          SubstanceConcentrationData& SubstanceConcentrationData::
          operator= (const SubstanceConcentrationData& x)
          {
            if (this != &x)
            {
              static_cast< ::xml_schema::type& > (*this) = x;
              this->Concentration_ = x.Concentration_;
              this->Name_ = x.Name_;
            }
  
            return *this;
          }
  
          SubstanceConcentrationData::
          ~SubstanceConcentrationData ()
          {
          }
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, SubstanceConcentrationData >
          _xsd_SubstanceConcentrationData_type_factory_init (
            "SubstanceConcentrationData",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // PharmacodynamicModifierData
          //
  
          PharmacodynamicModifierData::
          PharmacodynamicModifierData ()
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            EMax_ (this),
            EC50_ (this)
          {
          }
  
          PharmacodynamicModifierData::
          PharmacodynamicModifierData (const EMax_type& EMax,
                                       const EC50_type& EC50)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            EMax_ (EMax, this),
            EC50_ (EC50, this)
          {
          }
  
          PharmacodynamicModifierData::
          PharmacodynamicModifierData (::std::unique_ptr< EMax_type > EMax,
                                       ::std::unique_ptr< EC50_type > EC50)
          : ::mil::tatrc::physiology::datamodel::ObjectData (),
            EMax_ (std::move (EMax), this),
            EC50_ (std::move (EC50), this)
          {
          }
  
          PharmacodynamicModifierData::
          PharmacodynamicModifierData (const PharmacodynamicModifierData& x,
                                       ::xml_schema::flags f,
                                       ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (x, f, c),
            EMax_ (x.EMax_, f, this),
            EC50_ (x.EC50_, f, this)
          {
          }
  
          PharmacodynamicModifierData::
          PharmacodynamicModifierData (const ::xercesc::DOMElement& e,
                                       ::xml_schema::flags f,
                                       ::xml_schema::container* c)
          : ::mil::tatrc::physiology::datamodel::ObjectData (e, f | ::xml_schema::flags::base, c),
            EMax_ (this),
            EC50_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true);
              this->parse (p, f);
            }
          }
  
          void PharmacodynamicModifierData::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            this->::mil::tatrc::physiology::datamodel::ObjectData::parse (p, f);
  
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // EMax
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "EMax",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< EMax_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!EMax_.present ())
                  {
                    ::std::unique_ptr< EMax_type > r (
                      dynamic_cast< EMax_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->EMax_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // EC50
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "EC50",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< EC50_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!EC50_.present ())
                  {
                    ::std::unique_ptr< EC50_type > r (
                      dynamic_cast< EC50_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->EC50_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
  
            if (!EMax_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "EMax",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!EC50_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "EC50",
                "uri:/mil/tatrc/physiology/datamodel");
            }
          }
  
          PharmacodynamicModifierData* PharmacodynamicModifierData::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class PharmacodynamicModifierData (*this, f, c);
          }
  
          PharmacodynamicModifierData& PharmacodynamicModifierData::
          operator= (const PharmacodynamicModifierData& x)
          {
            if (this != &x)
            {
              static_cast< ::mil::tatrc::physiology::datamodel::ObjectData& > (*this) = x;
              this->EMax_ = x.EMax_;
              this->EC50_ = x.EC50_;
            }
  
            return *this;
          }
  
          PharmacodynamicModifierData::
          ~PharmacodynamicModifierData ()
          {
          }
  
          static
          const ::xsd::cxx::tree::type_factory_initializer< 0, char, PharmacodynamicModifierData >
          _xsd_PharmacodynamicModifierData_type_factory_init (
            "PharmacodynamicModifierData",
            "uri:/mil/tatrc/physiology/datamodel");
  
          // Systemic
          //
  
          Systemic::
          Systemic ()
          : ::xml_schema::type (),
            FractionExcretedInFeces_ (this),
            FractionExcretedInUrine_ (this),
            FractionMetabolizedInGut_ (this),
            FractionUnboundInPlasma_ (this),
            IntrinsicClearance_ (this),
            RenalClearance_ (this),
            SystemicClearance_ (this)
          {
          }
  
          Systemic::
          Systemic (const FractionExcretedInFeces_type& FractionExcretedInFeces,
                    const FractionUnboundInPlasma_type& FractionUnboundInPlasma,
                    const IntrinsicClearance_type& IntrinsicClearance,
                    const RenalClearance_type& RenalClearance,
                    const SystemicClearance_type& SystemicClearance)
          : ::xml_schema::type (),
            FractionExcretedInFeces_ (FractionExcretedInFeces, this),
            FractionExcretedInUrine_ (this),
            FractionMetabolizedInGut_ (this),
            FractionUnboundInPlasma_ (FractionUnboundInPlasma, this),
            IntrinsicClearance_ (IntrinsicClearance, this),
            RenalClearance_ (RenalClearance, this),
            SystemicClearance_ (SystemicClearance, this)
          {
          }
  
          Systemic::
          Systemic (::std::unique_ptr< FractionExcretedInFeces_type > FractionExcretedInFeces,
                    ::std::unique_ptr< FractionUnboundInPlasma_type > FractionUnboundInPlasma,
                    ::std::unique_ptr< IntrinsicClearance_type > IntrinsicClearance,
                    ::std::unique_ptr< RenalClearance_type > RenalClearance,
                    ::std::unique_ptr< SystemicClearance_type > SystemicClearance)
          : ::xml_schema::type (),
            FractionExcretedInFeces_ (std::move (FractionExcretedInFeces), this),
            FractionExcretedInUrine_ (this),
            FractionMetabolizedInGut_ (this),
            FractionUnboundInPlasma_ (std::move (FractionUnboundInPlasma), this),
            IntrinsicClearance_ (std::move (IntrinsicClearance), this),
            RenalClearance_ (std::move (RenalClearance), this),
            SystemicClearance_ (std::move (SystemicClearance), this)
          {
          }
  
          Systemic::
          Systemic (const Systemic& x,
                    ::xml_schema::flags f,
                    ::xml_schema::container* c)
          : ::xml_schema::type (x, f, c),
            FractionExcretedInFeces_ (x.FractionExcretedInFeces_, f, this),
            FractionExcretedInUrine_ (x.FractionExcretedInUrine_, f, this),
            FractionMetabolizedInGut_ (x.FractionMetabolizedInGut_, f, this),
            FractionUnboundInPlasma_ (x.FractionUnboundInPlasma_, f, this),
            IntrinsicClearance_ (x.IntrinsicClearance_, f, this),
            RenalClearance_ (x.RenalClearance_, f, this),
            SystemicClearance_ (x.SystemicClearance_, f, this)
          {
          }
  
          Systemic::
          Systemic (const ::xercesc::DOMElement& e,
                    ::xml_schema::flags f,
                    ::xml_schema::container* c)
          : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
            FractionExcretedInFeces_ (this),
            FractionExcretedInUrine_ (this),
            FractionMetabolizedInGut_ (this),
            FractionUnboundInPlasma_ (this),
            IntrinsicClearance_ (this),
            RenalClearance_ (this),
            SystemicClearance_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
              this->parse (p, f);
            }
          }
  
          void Systemic::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // FractionExcretedInFeces
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "FractionExcretedInFeces",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< FractionExcretedInFeces_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!FractionExcretedInFeces_.present ())
                  {
                    ::std::unique_ptr< FractionExcretedInFeces_type > r (
                      dynamic_cast< FractionExcretedInFeces_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->FractionExcretedInFeces_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // FractionExcretedInUrine
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "FractionExcretedInUrine",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< FractionExcretedInUrine_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->FractionExcretedInUrine_)
                  {
                    ::std::unique_ptr< FractionExcretedInUrine_type > r (
                      dynamic_cast< FractionExcretedInUrine_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->FractionExcretedInUrine_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // FractionMetabolizedInGut
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "FractionMetabolizedInGut",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< FractionMetabolizedInGut_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->FractionMetabolizedInGut_)
                  {
                    ::std::unique_ptr< FractionMetabolizedInGut_type > r (
                      dynamic_cast< FractionMetabolizedInGut_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->FractionMetabolizedInGut_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // FractionUnboundInPlasma
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "FractionUnboundInPlasma",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< FractionUnboundInPlasma_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!FractionUnboundInPlasma_.present ())
                  {
                    ::std::unique_ptr< FractionUnboundInPlasma_type > r (
                      dynamic_cast< FractionUnboundInPlasma_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->FractionUnboundInPlasma_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // IntrinsicClearance
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "IntrinsicClearance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< IntrinsicClearance_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!IntrinsicClearance_.present ())
                  {
                    ::std::unique_ptr< IntrinsicClearance_type > r (
                      dynamic_cast< IntrinsicClearance_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->IntrinsicClearance_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // RenalClearance
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "RenalClearance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< RenalClearance_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!RenalClearance_.present ())
                  {
                    ::std::unique_ptr< RenalClearance_type > r (
                      dynamic_cast< RenalClearance_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->RenalClearance_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // SystemicClearance
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "SystemicClearance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< SystemicClearance_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!SystemicClearance_.present ())
                  {
                    ::std::unique_ptr< SystemicClearance_type > r (
                      dynamic_cast< SystemicClearance_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->SystemicClearance_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
  
            if (!FractionExcretedInFeces_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "FractionExcretedInFeces",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!FractionUnboundInPlasma_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "FractionUnboundInPlasma",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!IntrinsicClearance_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "IntrinsicClearance",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!RenalClearance_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "RenalClearance",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!SystemicClearance_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "SystemicClearance",
                "uri:/mil/tatrc/physiology/datamodel");
            }
          }
  
          Systemic* Systemic::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class Systemic (*this, f, c);
          }
  
          Systemic& Systemic::
          operator= (const Systemic& x)
          {
            if (this != &x)
            {
              static_cast< ::xml_schema::type& > (*this) = x;
              this->FractionExcretedInFeces_ = x.FractionExcretedInFeces_;
              this->FractionExcretedInUrine_ = x.FractionExcretedInUrine_;
              this->FractionMetabolizedInGut_ = x.FractionMetabolizedInGut_;
              this->FractionUnboundInPlasma_ = x.FractionUnboundInPlasma_;
              this->IntrinsicClearance_ = x.IntrinsicClearance_;
              this->RenalClearance_ = x.RenalClearance_;
              this->SystemicClearance_ = x.SystemicClearance_;
            }
  
            return *this;
          }
  
          Systemic::
          ~Systemic ()
          {
          }
  
          // RenalDynamics
          //
  
          RenalDynamics::
          RenalDynamics ()
          : ::xml_schema::type (),
            Clearance_ (this),
            Regulation_ (this),
            FiltrationRate_ (this),
            ReabsorptionRate_ (this),
            ExcretionRate_ (this),
            GlomerularFilterability_ (this)
          {
          }
  
          RenalDynamics::
          RenalDynamics (const RenalDynamics& x,
                         ::xml_schema::flags f,
                         ::xml_schema::container* c)
          : ::xml_schema::type (x, f, c),
            Clearance_ (x.Clearance_, f, this),
            Regulation_ (x.Regulation_, f, this),
            FiltrationRate_ (x.FiltrationRate_, f, this),
            ReabsorptionRate_ (x.ReabsorptionRate_, f, this),
            ExcretionRate_ (x.ExcretionRate_, f, this),
            GlomerularFilterability_ (x.GlomerularFilterability_, f, this)
          {
          }
  
          RenalDynamics::
          RenalDynamics (const ::xercesc::DOMElement& e,
                         ::xml_schema::flags f,
                         ::xml_schema::container* c)
          : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
            Clearance_ (this),
            Regulation_ (this),
            FiltrationRate_ (this),
            ReabsorptionRate_ (this),
            ExcretionRate_ (this),
            GlomerularFilterability_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
              this->parse (p, f);
            }
          }
  
          void RenalDynamics::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // Clearance
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "Clearance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< Clearance_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->Clearance_)
                  {
                    ::std::unique_ptr< Clearance_type > r (
                      dynamic_cast< Clearance_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->Clearance_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // Regulation
              //
              if (n.name () == "Regulation" && n.namespace_ () == "uri:/mil/tatrc/physiology/datamodel")
              {
                ::std::unique_ptr< Regulation_type > r (
                  Regulation_traits::create (i, f, this));
  
                if (!this->Regulation_)
                {
                  this->Regulation_.set (::std::move (r));
                  continue;
                }
              }
  
              // FiltrationRate
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "FiltrationRate",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< FiltrationRate_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->FiltrationRate_)
                  {
                    ::std::unique_ptr< FiltrationRate_type > r (
                      dynamic_cast< FiltrationRate_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->FiltrationRate_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // ReabsorptionRate
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "ReabsorptionRate",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< ReabsorptionRate_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->ReabsorptionRate_)
                  {
                    ::std::unique_ptr< ReabsorptionRate_type > r (
                      dynamic_cast< ReabsorptionRate_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->ReabsorptionRate_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // ExcretionRate
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "ExcretionRate",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< ExcretionRate_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->ExcretionRate_)
                  {
                    ::std::unique_ptr< ExcretionRate_type > r (
                      dynamic_cast< ExcretionRate_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->ExcretionRate_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // GlomerularFilterability
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "GlomerularFilterability",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< GlomerularFilterability_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!this->GlomerularFilterability_)
                  {
                    ::std::unique_ptr< GlomerularFilterability_type > r (
                      dynamic_cast< GlomerularFilterability_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->GlomerularFilterability_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
          }
  
          RenalDynamics* RenalDynamics::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class RenalDynamics (*this, f, c);
          }
  
          RenalDynamics& RenalDynamics::
          operator= (const RenalDynamics& x)
          {
            if (this != &x)
            {
              static_cast< ::xml_schema::type& > (*this) = x;
              this->Clearance_ = x.Clearance_;
              this->Regulation_ = x.Regulation_;
              this->FiltrationRate_ = x.FiltrationRate_;
              this->ReabsorptionRate_ = x.ReabsorptionRate_;
              this->ExcretionRate_ = x.ExcretionRate_;
              this->GlomerularFilterability_ = x.GlomerularFilterability_;
            }
  
            return *this;
          }
  
          RenalDynamics::
          ~RenalDynamics ()
          {
          }
  
          // CellRegulation
          //
  
          CellRegulation::
          CellRegulation ()
          : ::xml_schema::type (),
            CellDeathRate_ (this),
            CellBirthRate_ (this)
          {
          }
  
          CellRegulation::
          CellRegulation (const CellDeathRate_type& CellDeathRate,
                          const CellBirthRate_type& CellBirthRate)
          : ::xml_schema::type (),
            CellDeathRate_ (CellDeathRate, this),
            CellBirthRate_ (CellBirthRate, this)
          {
          }
  
          CellRegulation::
          CellRegulation (::std::unique_ptr< CellDeathRate_type > CellDeathRate,
                          ::std::unique_ptr< CellBirthRate_type > CellBirthRate)
          : ::xml_schema::type (),
            CellDeathRate_ (std::move (CellDeathRate), this),
            CellBirthRate_ (std::move (CellBirthRate), this)
          {
          }
  
          CellRegulation::
          CellRegulation (const CellRegulation& x,
                          ::xml_schema::flags f,
                          ::xml_schema::container* c)
          : ::xml_schema::type (x, f, c),
            CellDeathRate_ (x.CellDeathRate_, f, this),
            CellBirthRate_ (x.CellBirthRate_, f, this)
          {
          }
  
          CellRegulation::
          CellRegulation (const ::xercesc::DOMElement& e,
                          ::xml_schema::flags f,
                          ::xml_schema::container* c)
          : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
            CellDeathRate_ (this),
            CellBirthRate_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
              this->parse (p, f);
            }
          }
  
          void CellRegulation::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // CellDeathRate
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "CellDeathRate",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< CellDeathRate_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!CellDeathRate_.present ())
                  {
                    ::std::unique_ptr< CellDeathRate_type > r (
                      dynamic_cast< CellDeathRate_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->CellDeathRate_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // CellBirthRate
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "CellBirthRate",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< CellBirthRate_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!CellBirthRate_.present ())
                  {
                    ::std::unique_ptr< CellBirthRate_type > r (
                      dynamic_cast< CellBirthRate_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->CellBirthRate_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
  
            if (!CellDeathRate_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "CellDeathRate",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!CellBirthRate_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "CellBirthRate",
                "uri:/mil/tatrc/physiology/datamodel");
            }
          }
  
          CellRegulation* CellRegulation::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class CellRegulation (*this, f, c);
          }
  
          CellRegulation& CellRegulation::
          operator= (const CellRegulation& x)
          {
            if (this != &x)
            {
              static_cast< ::xml_schema::type& > (*this) = x;
              this->CellDeathRate_ = x.CellDeathRate_;
              this->CellBirthRate_ = x.CellBirthRate_;
            }
  
            return *this;
          }
  
          CellRegulation::
          ~CellRegulation ()
          {
          }
  
          // Regulation
          //
  
          Regulation::
          Regulation ()
          : ::xml_schema::type (),
            ChargeInBlood_ (this),
            FractionUnboundInPlasma_ (this),
            ReabsorptionRatio_ (this),
            TransportMaximum_ (this)
          {
          }
  
          Regulation::
          Regulation (const ChargeInBlood_type& ChargeInBlood,
                      const FractionUnboundInPlasma_type& FractionUnboundInPlasma,
                      const ReabsorptionRatio_type& ReabsorptionRatio,
                      const TransportMaximum_type& TransportMaximum)
          : ::xml_schema::type (),
            ChargeInBlood_ (ChargeInBlood, this),
            FractionUnboundInPlasma_ (FractionUnboundInPlasma, this),
            ReabsorptionRatio_ (ReabsorptionRatio, this),
            TransportMaximum_ (TransportMaximum, this)
          {
          }
  
          Regulation::
          Regulation (const ChargeInBlood_type& ChargeInBlood,
                      ::std::unique_ptr< FractionUnboundInPlasma_type > FractionUnboundInPlasma,
                      ::std::unique_ptr< ReabsorptionRatio_type > ReabsorptionRatio,
                      ::std::unique_ptr< TransportMaximum_type > TransportMaximum)
          : ::xml_schema::type (),
            ChargeInBlood_ (ChargeInBlood, this),
            FractionUnboundInPlasma_ (std::move (FractionUnboundInPlasma), this),
            ReabsorptionRatio_ (std::move (ReabsorptionRatio), this),
            TransportMaximum_ (std::move (TransportMaximum), this)
          {
          }
  
          Regulation::
          Regulation (::std::unique_ptr< ChargeInBlood_type > ChargeInBlood,
                      ::std::unique_ptr< FractionUnboundInPlasma_type > FractionUnboundInPlasma,
                      ::std::unique_ptr< ReabsorptionRatio_type > ReabsorptionRatio,
                      ::std::unique_ptr< TransportMaximum_type > TransportMaximum)
          : ::xml_schema::type (),
            ChargeInBlood_ (std::move (ChargeInBlood), this),
            FractionUnboundInPlasma_ (std::move (FractionUnboundInPlasma), this),
            ReabsorptionRatio_ (std::move (ReabsorptionRatio), this),
            TransportMaximum_ (std::move (TransportMaximum), this)
          {
          }
  
          Regulation::
          Regulation (const Regulation& x,
                      ::xml_schema::flags f,
                      ::xml_schema::container* c)
          : ::xml_schema::type (x, f, c),
            ChargeInBlood_ (x.ChargeInBlood_, f, this),
            FractionUnboundInPlasma_ (x.FractionUnboundInPlasma_, f, this),
            ReabsorptionRatio_ (x.ReabsorptionRatio_, f, this),
            TransportMaximum_ (x.TransportMaximum_, f, this)
          {
          }
  
          Regulation::
          Regulation (const ::xercesc::DOMElement& e,
                      ::xml_schema::flags f,
                      ::xml_schema::container* c)
          : ::xml_schema::type (e, f | ::xml_schema::flags::base, c),
            ChargeInBlood_ (this),
            FractionUnboundInPlasma_ (this),
            ReabsorptionRatio_ (this),
            TransportMaximum_ (this)
          {
            if ((f & ::xml_schema::flags::base) == 0)
            {
              ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false);
              this->parse (p, f);
            }
          }
  
          void Regulation::
          parse (::xsd::cxx::xml::dom::parser< char >& p,
                 ::xml_schema::flags f)
          {
            for (; p.more_content (); p.next_content (false))
            {
              const ::xercesc::DOMElement& i (p.cur_element ());
              const ::xsd::cxx::xml::qualified_name< char > n (
                ::xsd::cxx::xml::dom::name< char > (i));
  
              // ChargeInBlood
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "ChargeInBlood",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< ChargeInBlood_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!ChargeInBlood_.present ())
                  {
                    ::std::unique_ptr< ChargeInBlood_type > r (
                      dynamic_cast< ChargeInBlood_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->ChargeInBlood_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // FractionUnboundInPlasma
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "FractionUnboundInPlasma",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< FractionUnboundInPlasma_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!FractionUnboundInPlasma_.present ())
                  {
                    ::std::unique_ptr< FractionUnboundInPlasma_type > r (
                      dynamic_cast< FractionUnboundInPlasma_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->FractionUnboundInPlasma_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // ReabsorptionRatio
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "ReabsorptionRatio",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< ReabsorptionRatio_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!ReabsorptionRatio_.present ())
                  {
                    ::std::unique_ptr< ReabsorptionRatio_type > r (
                      dynamic_cast< ReabsorptionRatio_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->ReabsorptionRatio_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              // TransportMaximum
              //
              {
                ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
                  ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                    "TransportMaximum",
                    "uri:/mil/tatrc/physiology/datamodel",
                    &::xsd::cxx::tree::factory_impl< TransportMaximum_type >,
                    false, true, i, n, f, this));
  
                if (tmp.get () != 0)
                {
                  if (!TransportMaximum_.present ())
                  {
                    ::std::unique_ptr< TransportMaximum_type > r (
                      dynamic_cast< TransportMaximum_type* > (tmp.get ()));
  
                    if (r.get ())
                      tmp.release ();
                    else
                      throw ::xsd::cxx::tree::not_derived< char > ();
  
                    this->TransportMaximum_.set (::std::move (r));
                    continue;
                  }
                }
              }
  
              break;
            }
  
            if (!ChargeInBlood_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "ChargeInBlood",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!FractionUnboundInPlasma_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "FractionUnboundInPlasma",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!ReabsorptionRatio_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "ReabsorptionRatio",
                "uri:/mil/tatrc/physiology/datamodel");
            }
  
            if (!TransportMaximum_.present ())
            {
              throw ::xsd::cxx::tree::expected_element< char > (
                "TransportMaximum",
                "uri:/mil/tatrc/physiology/datamodel");
            }
          }
  
          Regulation* Regulation::
          _clone (::xml_schema::flags f,
                  ::xml_schema::container* c) const
          {
            return new class Regulation (*this, f, c);
          }
  
          Regulation& Regulation::
          operator= (const Regulation& x)
          {
            if (this != &x)
            {
              static_cast< ::xml_schema::type& > (*this) = x;
              this->ChargeInBlood_ = x.ChargeInBlood_;
              this->FractionUnboundInPlasma_ = x.FractionUnboundInPlasma_;
              this->ReabsorptionRatio_ = x.ReabsorptionRatio_;
              this->TransportMaximum_ = x.TransportMaximum_;
            }
  
            return *this;
          }
  
          Regulation::
          ~Regulation ()
          {
          }
        }
      }
    }
  }
  
  #include <ostream>
  
  #include <xsd/cxx/tree/std-ostream-map.hxx>
  
  namespace _xsd
  {
    static
    const ::xsd::cxx::tree::std_ostream_plate< 0, char >
    std_ostream_plate_init;
  }
  
  namespace mil
  {
    namespace tatrc
    {
      namespace physiology
      {
        namespace datamodel
        {
          ::std::ostream&
          operator<< (::std::ostream& o, enumSubstanceState::value i)
          {
            return o << enumSubstanceState::_xsd_enumSubstanceState_literals_[i];
          }
  
          ::std::ostream&
          operator<< (::std::ostream& o, const enumSubstanceState& i)
          {
            return o << static_cast< const ::xml_schema::string& > (i);
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, enumSubstanceState >
          _xsd_enumSubstanceState_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, enumSubstanceIonicState::value i)
          {
            return o << enumSubstanceIonicState::_xsd_enumSubstanceIonicState_literals_[i];
          }
  
          ::std::ostream&
          operator<< (::std::ostream& o, const enumSubstanceIonicState& i)
          {
            return o << static_cast< const ::xml_schema::string& > (i);
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, enumSubstanceIonicState >
          _xsd_enumSubstanceIonicState_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, enumSubstanceBindingProtein::value i)
          {
            return o << enumSubstanceBindingProtein::_xsd_enumSubstanceBindingProtein_literals_[i];
          }
  
          ::std::ostream&
          operator<< (::std::ostream& o, const enumSubstanceBindingProtein& i)
          {
            return o << static_cast< const ::xml_schema::string& > (i);
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, enumSubstanceBindingProtein >
          _xsd_enumSubstanceBindingProtein_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, enumCharge::value i)
          {
            return o << enumCharge::_xsd_enumCharge_literals_[i];
          }
  
          ::std::ostream&
          operator<< (::std::ostream& o, const enumCharge& i)
          {
            return o << static_cast< const ::xml_schema::string& > (i);
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, enumCharge >
          _xsd_enumCharge_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, enumSubstanceClass::value i)
          {
            return o << enumSubstanceClass::_xsd_enumSubstanceClass_literals_[i];
          }
  
          ::std::ostream&
          operator<< (::std::ostream& o, const enumSubstanceClass& i)
          {
            return o << static_cast< const ::xml_schema::string& > (i);
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, enumSubstanceClass >
          _xsd_enumSubstanceClass_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const SubstanceAerosolizationData& i)
          {
            o << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "BronchioleModifier: ";
              om.insert (o, i.BronchioleModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "InflammationCoefficient: ";
              om.insert (o, i.InflammationCoefficient ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "ParticulateSizeDistribution: ";
              om.insert (o, i.ParticulateSizeDistribution ());
            }
  
            return o;
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, SubstanceAerosolizationData >
          _xsd_SubstanceAerosolizationData_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const SubstancePharmacokineticsData& i)
          {
            o << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.Physicochemicals ())
              {
                o << ::std::endl << "Physicochemicals: ";
                om.insert (o, *i.Physicochemicals ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              for (SubstancePharmacokineticsData::TissueKinetics_const_iterator
                   b (i.TissueKinetics ().begin ()), e (i.TissueKinetics ().end ());
                   b != e; ++b)
              {
                o << ::std::endl << "TissueKinetics: ";
                om.insert (o, *b);
              }
            }
  
            return o;
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, SubstancePharmacokineticsData >
          _xsd_SubstancePharmacokineticsData_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const SubstancePhysicochemicalData& i)
          {
            o << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              for (SubstancePhysicochemicalData::AcidDissociationConstant_const_iterator
                   b (i.AcidDissociationConstant ().begin ()), e (i.AcidDissociationConstant ().end ());
                   b != e; ++b)
              {
                o << ::std::endl << "AcidDissociationConstant: ";
                om.insert (o, *b);
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "BindingProtein: ";
              om.insert (o, i.BindingProtein ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "BloodPlasmaRatio: ";
              om.insert (o, i.BloodPlasmaRatio ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "FractionUnboundInPlasma: ";
              om.insert (o, i.FractionUnboundInPlasma ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "IonicState: ";
              om.insert (o, i.IonicState ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "LogP: ";
              om.insert (o, i.LogP ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.HydrogenBondCount ())
              {
                o << ::std::endl << "HydrogenBondCount: ";
                om.insert (o, *i.HydrogenBondCount ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.PolarSurfaceArea ())
              {
                o << ::std::endl << "PolarSurfaceArea: ";
                om.insert (o, *i.PolarSurfaceArea ());
              }
            }
  
            return o;
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, SubstancePhysicochemicalData >
          _xsd_SubstancePhysicochemicalData_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const SubstanceTissuePharmacokineticsData& i)
          {
            o << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "Name: ";
              om.insert (o, i.Name ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.PartitionCoefficient ())
              {
                o << ::std::endl << "PartitionCoefficient: ";
                om.insert (o, *i.PartitionCoefficient ());
              }
            }
  
            return o;
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, SubstanceTissuePharmacokineticsData >
          _xsd_SubstanceTissuePharmacokineticsData_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const SubstancePharmacodynamicsData& i)
          {
            o << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "EffectSiteRateConstant: ";
              om.insert (o, i.EffectSiteRateConstant ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "EMaxShapeParameter: ";
              om.insert (o, i.EMaxShapeParameter ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "AntibacterialEffect: ";
              om.insert (o, i.AntibacterialEffect ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "Bronchodilation: ";
              om.insert (o, i.Bronchodilation ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "CentralNervousModifier: ";
              om.insert (o, i.CentralNervousModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "DiastolicPressureModifier: ";
              om.insert (o, i.DiastolicPressureModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "FeverModifier: ";
              om.insert (o, i.FeverModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "HeartRateModifier: ";
              om.insert (o, i.HeartRateModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "HemorrhageModifier: ";
              om.insert (o, i.HemorrhageModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "NeuromuscularBlock: ";
              om.insert (o, i.NeuromuscularBlock ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "PainModifier: ";
              om.insert (o, i.PainModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "PupilReactivityModifier: ";
              om.insert (o, i.PupilReactivityModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "PupilSizeModifier: ";
              om.insert (o, i.PupilSizeModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "RespirationRateModifier: ";
              om.insert (o, i.RespirationRateModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "Sedation: ";
              om.insert (o, i.Sedation ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "SystolicPressureModifier: ";
              om.insert (o, i.SystolicPressureModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "TidalVolumeModifier: ";
              om.insert (o, i.TidalVolumeModifier ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "TubularPermeabilityModifier: ";
              om.insert (o, i.TubularPermeabilityModifier ());
            }
  
            return o;
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, SubstancePharmacodynamicsData >
          _xsd_SubstancePharmacodynamicsData_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const SubstanceClearanceData& i)
          {
            o << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            if (i.Systemic ())
            {
              o << ::std::endl << "Systemic: " << *i.Systemic ();
            }
  
            if (i.RenalDynamics ())
            {
              o << ::std::endl << "RenalDynamics: " << *i.RenalDynamics ();
            }
  
            if (i.CellRegulation ())
            {
              o << ::std::endl << "CellRegulation: " << *i.CellRegulation ();
            }
  
            return o;
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, SubstanceClearanceData >
          _xsd_SubstanceClearanceData_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const SubstanceData& i)
          {
            o << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "Name: ";
              om.insert (o, i.Name ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.Classification ())
              {
                o << ::std::endl << "Classification: ";
                om.insert (o, *i.Classification ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.Density ())
              {
                o << ::std::endl << "Density: ";
                om.insert (o, *i.Density ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.MolarMass ())
              {
                o << ::std::endl << "MolarMass: ";
                om.insert (o, *i.MolarMass ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.State ())
              {
                o << ::std::endl << "State: ";
                om.insert (o, *i.State ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.MaximumDiffusionFlux ())
              {
                o << ::std::endl << "MaximumDiffusionFlux: ";
                om.insert (o, *i.MaximumDiffusionFlux ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.MichaelisCoefficient ())
              {
                o << ::std::endl << "MichaelisCoefficient: ";
                om.insert (o, *i.MichaelisCoefficient ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.MembraneResistance ())
              {
                o << ::std::endl << "MembraneResistance: ";
                om.insert (o, *i.MembraneResistance ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.Aerosolization ())
              {
                o << ::std::endl << "Aerosolization: ";
                om.insert (o, *i.Aerosolization ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.AreaUnderCurve ())
              {
                o << ::std::endl << "AreaUnderCurve: ";
                om.insert (o, *i.AreaUnderCurve ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.BloodConcentration ())
              {
                o << ::std::endl << "BloodConcentration: ";
                om.insert (o, *i.BloodConcentration ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.EffectSiteConcentration ())
              {
                o << ::std::endl << "EffectSiteConcentration: ";
                om.insert (o, *i.EffectSiteConcentration ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.MassInBody ())
              {
                o << ::std::endl << "MassInBody: ";
                om.insert (o, *i.MassInBody ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.MassInBlood ())
              {
                o << ::std::endl << "MassInBlood: ";
                om.insert (o, *i.MassInBlood ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.MassInTissue ())
              {
                o << ::std::endl << "MassInTissue: ";
                om.insert (o, *i.MassInTissue ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.PlasmaConcentration ())
              {
                o << ::std::endl << "PlasmaConcentration: ";
                om.insert (o, *i.PlasmaConcentration ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.SystemicMassCleared ())
              {
                o << ::std::endl << "SystemicMassCleared: ";
                om.insert (o, *i.SystemicMassCleared ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.TissueConcentration ())
              {
                o << ::std::endl << "TissueConcentration: ";
                om.insert (o, *i.TissueConcentration ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.AlveolarTransfer ())
              {
                o << ::std::endl << "AlveolarTransfer: ";
                om.insert (o, *i.AlveolarTransfer ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.DiffusingCapacity ())
              {
                o << ::std::endl << "DiffusingCapacity: ";
                om.insert (o, *i.DiffusingCapacity ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.EndTidalFraction ())
              {
                o << ::std::endl << "EndTidalFraction: ";
                om.insert (o, *i.EndTidalFraction ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.EndTidalPressure ())
              {
                o << ::std::endl << "EndTidalPressure: ";
                om.insert (o, *i.EndTidalPressure ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.RelativeDiffusionCoefficient ())
              {
                o << ::std::endl << "RelativeDiffusionCoefficient: ";
                om.insert (o, *i.RelativeDiffusionCoefficient ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.SolubilityCoefficient ())
              {
                o << ::std::endl << "SolubilityCoefficient: ";
                om.insert (o, *i.SolubilityCoefficient ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.Clearance ())
              {
                o << ::std::endl << "Clearance: ";
                om.insert (o, *i.Clearance ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.Pharmacokinetics ())
              {
                o << ::std::endl << "Pharmacokinetics: ";
                om.insert (o, *i.Pharmacokinetics ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.Pharmacodynamics ())
              {
                o << ::std::endl << "Pharmacodynamics: ";
                om.insert (o, *i.Pharmacodynamics ());
              }
            }
  
            return o;
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, SubstanceData >
          _xsd_SubstanceData_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const SubstanceCompoundData& i)
          {
            o << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "Name: ";
              om.insert (o, i.Name ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.Classification ())
              {
                o << ::std::endl << "Classification: ";
                om.insert (o, *i.Classification ());
              }
            }
  
            if (i.BloodRHFactor ())
            {
              o << ::std::endl << "BloodRHFactor: " << *i.BloodRHFactor ();
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              for (SubstanceCompoundData::Component_const_iterator
                   b (i.Component ().begin ()), e (i.Component ().end ());
                   b != e; ++b)
              {
                o << ::std::endl << "Component: ";
                om.insert (o, *b);
              }
            }
  
            return o;
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, SubstanceCompoundData >
          _xsd_SubstanceCompoundData_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const SubstanceFractionData& i)
          {
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "FractionAmount: ";
              om.insert (o, i.FractionAmount ());
            }
  
            o << ::std::endl << "Name: " << i.Name ();
            return o;
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, SubstanceFractionData >
          _xsd_SubstanceFractionData_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const SubstanceConcentrationData& i)
          {
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "Concentration: ";
              om.insert (o, i.Concentration ());
            }
  
            o << ::std::endl << "Name: " << i.Name ();
            return o;
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, SubstanceConcentrationData >
          _xsd_SubstanceConcentrationData_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const PharmacodynamicModifierData& i)
          {
            o << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "EMax: ";
              om.insert (o, i.EMax ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "EC50: ";
              om.insert (o, i.EC50 ());
            }
  
            return o;
          }
  
          static
          const ::xsd::cxx::tree::std_ostream_initializer< 0, char, PharmacodynamicModifierData >
          _xsd_PharmacodynamicModifierData_std_ostream_init;
  
          ::std::ostream&
          operator<< (::std::ostream& o, const Systemic& i)
          {
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "FractionExcretedInFeces: ";
              om.insert (o, i.FractionExcretedInFeces ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.FractionExcretedInUrine ())
              {
                o << ::std::endl << "FractionExcretedInUrine: ";
                om.insert (o, *i.FractionExcretedInUrine ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.FractionMetabolizedInGut ())
              {
                o << ::std::endl << "FractionMetabolizedInGut: ";
                om.insert (o, *i.FractionMetabolizedInGut ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "FractionUnboundInPlasma: ";
              om.insert (o, i.FractionUnboundInPlasma ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "IntrinsicClearance: ";
              om.insert (o, i.IntrinsicClearance ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "RenalClearance: ";
              om.insert (o, i.RenalClearance ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "SystemicClearance: ";
              om.insert (o, i.SystemicClearance ());
            }
  
            return o;
          }
  
          ::std::ostream&
          operator<< (::std::ostream& o, const RenalDynamics& i)
          {
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.Clearance ())
              {
                o << ::std::endl << "Clearance: ";
                om.insert (o, *i.Clearance ());
              }
            }
  
            if (i.Regulation ())
            {
              o << ::std::endl << "Regulation: " << *i.Regulation ();
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.FiltrationRate ())
              {
                o << ::std::endl << "FiltrationRate: ";
                om.insert (o, *i.FiltrationRate ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.ReabsorptionRate ())
              {
                o << ::std::endl << "ReabsorptionRate: ";
                om.insert (o, *i.ReabsorptionRate ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.ExcretionRate ())
              {
                o << ::std::endl << "ExcretionRate: ";
                om.insert (o, *i.ExcretionRate ());
              }
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              if (i.GlomerularFilterability ())
              {
                o << ::std::endl << "GlomerularFilterability: ";
                om.insert (o, *i.GlomerularFilterability ());
              }
            }
  
            return o;
          }
  
          ::std::ostream&
          operator<< (::std::ostream& o, const CellRegulation& i)
          {
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "CellDeathRate: ";
              om.insert (o, i.CellDeathRate ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "CellBirthRate: ";
              om.insert (o, i.CellBirthRate ());
            }
  
            return o;
          }
  
          ::std::ostream&
          operator<< (::std::ostream& o, const Regulation& i)
          {
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "ChargeInBlood: ";
              om.insert (o, i.ChargeInBlood ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "FractionUnboundInPlasma: ";
              om.insert (o, i.FractionUnboundInPlasma ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "ReabsorptionRatio: ";
              om.insert (o, i.ReabsorptionRatio ());
            }
  
            {
              ::xsd::cxx::tree::std_ostream_map< char >& om (
                ::xsd::cxx::tree::std_ostream_map_instance< 0, char > ());
  
              o << ::std::endl << "TransportMaximum: ";
              om.insert (o, i.TransportMaximum ());
            }
  
            return o;
          }
        }
      }
    }
  }
  
  #include <istream>
  #include <xsd/cxx/xml/sax/std-input-source.hxx>
  #include <xsd/cxx/tree/error-handler.hxx>
  
  namespace mil
  {
    namespace tatrc
    {
      namespace physiology
      {
        namespace datamodel
        {
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (const ::std::string& u,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xsd::cxx::tree::error_handler< char > h;
  
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                u, h, p, f));
  
            h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData > (
              ::mil::tatrc::physiology::datamodel::Substance (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (const ::std::string& u,
                     ::xml_schema::error_handler& h,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                u, h, p, f));
  
            if (!d.get ())
              throw ::xsd::cxx::tree::parsing< char > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData > (
              ::mil::tatrc::physiology::datamodel::Substance (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (const ::std::string& u,
                     ::xercesc::DOMErrorHandler& h,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                u, h, p, f));
  
            if (!d.get ())
              throw ::xsd::cxx::tree::parsing< char > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData > (
              ::mil::tatrc::physiology::datamodel::Substance (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (::std::istream& is,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xsd::cxx::xml::sax::std_input_source isrc (is);
            return ::mil::tatrc::physiology::datamodel::Substance (isrc, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (::std::istream& is,
                     ::xml_schema::error_handler& h,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xsd::cxx::xml::sax::std_input_source isrc (is);
            return ::mil::tatrc::physiology::datamodel::Substance (isrc, h, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (::std::istream& is,
                     ::xercesc::DOMErrorHandler& h,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::sax::std_input_source isrc (is);
            return ::mil::tatrc::physiology::datamodel::Substance (isrc, h, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (::std::istream& is,
                     const ::std::string& sid,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
            return ::mil::tatrc::physiology::datamodel::Substance (isrc, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (::std::istream& is,
                     const ::std::string& sid,
                     ::xml_schema::error_handler& h,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
            return ::mil::tatrc::physiology::datamodel::Substance (isrc, h, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (::std::istream& is,
                     const ::std::string& sid,
                     ::xercesc::DOMErrorHandler& h,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
            return ::mil::tatrc::physiology::datamodel::Substance (isrc, h, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (::xercesc::InputSource& i,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xsd::cxx::tree::error_handler< char > h;
  
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                i, h, p, f));
  
            h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData > (
              ::mil::tatrc::physiology::datamodel::Substance (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (::xercesc::InputSource& i,
                     ::xml_schema::error_handler& h,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                i, h, p, f));
  
            if (!d.get ())
              throw ::xsd::cxx::tree::parsing< char > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData > (
              ::mil::tatrc::physiology::datamodel::Substance (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (::xercesc::InputSource& i,
                     ::xercesc::DOMErrorHandler& h,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                i, h, p, f));
  
            if (!d.get ())
              throw ::xsd::cxx::tree::parsing< char > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData > (
              ::mil::tatrc::physiology::datamodel::Substance (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (const ::xercesc::DOMDocument& doc,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties& p)
          {
            if (f & ::xml_schema::flags::keep_dom)
            {
              ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
                static_cast< ::xercesc::DOMDocument* > (doc.cloneNode (true)));
  
              return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData > (
                ::mil::tatrc::physiology::datamodel::Substance (
                  std::move (d), f | ::xml_schema::flags::own_dom, p));
            }
  
            const ::xercesc::DOMElement& e (*doc.getDocumentElement ());
            const ::xsd::cxx::xml::qualified_name< char > n (
              ::xsd::cxx::xml::dom::name< char > (e));
  
            ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
              ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                "Substance",
                "uri:/mil/tatrc/physiology/datamodel",
                &::xsd::cxx::tree::factory_impl< ::mil::tatrc::physiology::datamodel::SubstanceData >,
                true, true, e, n, f, 0));
  
            if (tmp.get () != 0)
            {
              ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData > r (
                dynamic_cast< ::mil::tatrc::physiology::datamodel::SubstanceData* > (tmp.get ()));
  
              if (r.get ())
                tmp.release ();
              else
                throw ::xsd::cxx::tree::not_derived< char > ();
  
              return r;
            }
  
            throw ::xsd::cxx::tree::unexpected_element < char > (
              n.name (),
              n.namespace_ (),
              "Substance",
              "uri:/mil/tatrc/physiology/datamodel");
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData >
          Substance (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
                     ::xml_schema::flags f,
                     const ::xml_schema::properties&)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > c (
              ((f & ::xml_schema::flags::keep_dom) &&
               !(f & ::xml_schema::flags::own_dom))
              ? static_cast< ::xercesc::DOMDocument* > (d->cloneNode (true))
              : 0);
  
            ::xercesc::DOMDocument& doc (c.get () ? *c : *d);
            const ::xercesc::DOMElement& e (*doc.getDocumentElement ());
  
            const ::xsd::cxx::xml::qualified_name< char > n (
              ::xsd::cxx::xml::dom::name< char > (e));
  
            if (f & ::xml_schema::flags::keep_dom)
              doc.setUserData (::xml_schema::dom::tree_node_key,
                               (c.get () ? &c : &d),
                               0);
  
            ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
              ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                "Substance",
                "uri:/mil/tatrc/physiology/datamodel",
                &::xsd::cxx::tree::factory_impl< ::mil::tatrc::physiology::datamodel::SubstanceData >,
                true, true, e, n, f, 0));
  
            if (tmp.get () != 0)
            {
  
              ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceData > r (
                dynamic_cast< ::mil::tatrc::physiology::datamodel::SubstanceData* > (tmp.get ()));
  
              if (r.get ())
                tmp.release ();
              else
                throw ::xsd::cxx::tree::not_derived< char > ();
  
              return r;
            }
  
            throw ::xsd::cxx::tree::unexpected_element < char > (
              n.name (),
              n.namespace_ (),
              "Substance",
              "uri:/mil/tatrc/physiology/datamodel");
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (const ::std::string& u,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xsd::cxx::tree::error_handler< char > h;
  
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                u, h, p, f));
  
            h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData > (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (const ::std::string& u,
                             ::xml_schema::error_handler& h,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                u, h, p, f));
  
            if (!d.get ())
              throw ::xsd::cxx::tree::parsing< char > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData > (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (const ::std::string& u,
                             ::xercesc::DOMErrorHandler& h,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                u, h, p, f));
  
            if (!d.get ())
              throw ::xsd::cxx::tree::parsing< char > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData > (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (::std::istream& is,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xsd::cxx::xml::sax::std_input_source isrc (is);
            return ::mil::tatrc::physiology::datamodel::SubstanceCompound (isrc, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (::std::istream& is,
                             ::xml_schema::error_handler& h,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xsd::cxx::xml::sax::std_input_source isrc (is);
            return ::mil::tatrc::physiology::datamodel::SubstanceCompound (isrc, h, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (::std::istream& is,
                             ::xercesc::DOMErrorHandler& h,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::sax::std_input_source isrc (is);
            return ::mil::tatrc::physiology::datamodel::SubstanceCompound (isrc, h, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (::std::istream& is,
                             const ::std::string& sid,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
            return ::mil::tatrc::physiology::datamodel::SubstanceCompound (isrc, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (::std::istream& is,
                             const ::std::string& sid,
                             ::xml_schema::error_handler& h,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0,
              (f & ::xml_schema::flags::keep_dom) == 0);
  
            ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
            return ::mil::tatrc::physiology::datamodel::SubstanceCompound (isrc, h, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (::std::istream& is,
                             const ::std::string& sid,
                             ::xercesc::DOMErrorHandler& h,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xsd::cxx::xml::sax::std_input_source isrc (is, sid);
            return ::mil::tatrc::physiology::datamodel::SubstanceCompound (isrc, h, f, p);
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (::xercesc::InputSource& i,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xsd::cxx::tree::error_handler< char > h;
  
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                i, h, p, f));
  
            h.throw_if_failed< ::xsd::cxx::tree::parsing< char > > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData > (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (::xercesc::InputSource& i,
                             ::xml_schema::error_handler& h,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                i, h, p, f));
  
            if (!d.get ())
              throw ::xsd::cxx::tree::parsing< char > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData > (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (::xercesc::InputSource& i,
                             ::xercesc::DOMErrorHandler& h,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::xsd::cxx::xml::dom::parse< char > (
                i, h, p, f));
  
            if (!d.get ())
              throw ::xsd::cxx::tree::parsing< char > ();
  
            return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData > (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (
                std::move (d), f | ::xml_schema::flags::own_dom, p));
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (const ::xercesc::DOMDocument& doc,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties& p)
          {
            if (f & ::xml_schema::flags::keep_dom)
            {
              ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
                static_cast< ::xercesc::DOMDocument* > (doc.cloneNode (true)));
  
              return ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData > (
                ::mil::tatrc::physiology::datamodel::SubstanceCompound (
                  std::move (d), f | ::xml_schema::flags::own_dom, p));
            }
  
            const ::xercesc::DOMElement& e (*doc.getDocumentElement ());
            const ::xsd::cxx::xml::qualified_name< char > n (
              ::xsd::cxx::xml::dom::name< char > (e));
  
            ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
              ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                "SubstanceCompound",
                "uri:/mil/tatrc/physiology/datamodel",
                &::xsd::cxx::tree::factory_impl< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >,
                true, true, e, n, f, 0));
  
            if (tmp.get () != 0)
            {
              ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData > r (
                dynamic_cast< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData* > (tmp.get ()));
  
              if (r.get ())
                tmp.release ();
              else
                throw ::xsd::cxx::tree::not_derived< char > ();
  
              return r;
            }
  
            throw ::xsd::cxx::tree::unexpected_element < char > (
              n.name (),
              n.namespace_ (),
              "SubstanceCompound",
              "uri:/mil/tatrc/physiology/datamodel");
          }
  
          ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >
          SubstanceCompound (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
                             ::xml_schema::flags f,
                             const ::xml_schema::properties&)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > c (
              ((f & ::xml_schema::flags::keep_dom) &&
               !(f & ::xml_schema::flags::own_dom))
              ? static_cast< ::xercesc::DOMDocument* > (d->cloneNode (true))
              : 0);
  
            ::xercesc::DOMDocument& doc (c.get () ? *c : *d);
            const ::xercesc::DOMElement& e (*doc.getDocumentElement ());
  
            const ::xsd::cxx::xml::qualified_name< char > n (
              ::xsd::cxx::xml::dom::name< char > (e));
  
            if (f & ::xml_schema::flags::keep_dom)
              doc.setUserData (::xml_schema::dom::tree_node_key,
                               (c.get () ? &c : &d),
                               0);
  
            ::std::unique_ptr< ::xsd::cxx::tree::type > tmp (
              ::xsd::cxx::tree::type_factory_map_instance< 0, char > ().create (
                "SubstanceCompound",
                "uri:/mil/tatrc/physiology/datamodel",
                &::xsd::cxx::tree::factory_impl< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData >,
                true, true, e, n, f, 0));
  
            if (tmp.get () != 0)
            {
  
              ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData > r (
                dynamic_cast< ::mil::tatrc::physiology::datamodel::SubstanceCompoundData* > (tmp.get ()));
  
              if (r.get ())
                tmp.release ();
              else
                throw ::xsd::cxx::tree::not_derived< char > ();
  
              return r;
            }
  
            throw ::xsd::cxx::tree::unexpected_element < char > (
              n.name (),
              n.namespace_ (),
              "SubstanceCompound",
              "uri:/mil/tatrc/physiology/datamodel");
          }
        }
      }
    }
  }
  
  #include <ostream>
  #include <xsd/cxx/tree/error-handler.hxx>
  #include <xsd/cxx/xml/dom/serialization-source.hxx>
  
  #include <xsd/cxx/tree/type-serializer-map.hxx>
  
  namespace _xsd
  {
    static
    const ::xsd::cxx::tree::type_serializer_plate< 0, char >
    type_serializer_plate_init;
  }
  
  namespace mil
  {
    namespace tatrc
    {
      namespace physiology
      {
        namespace datamodel
        {
          void
          operator<< (::xercesc::DOMElement& e, const enumSubstanceState& i)
          {
            e << static_cast< const ::xml_schema::string& > (i);
          }
  
          void
          operator<< (::xercesc::DOMAttr& a, const enumSubstanceState& i)
          {
            a << static_cast< const ::xml_schema::string& > (i);
          }
  
          void
          operator<< (::xml_schema::list_stream& l,
                      const enumSubstanceState& i)
          {
            l << static_cast< const ::xml_schema::string& > (i);
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, enumSubstanceState >
          _xsd_enumSubstanceState_type_serializer_init (
            "enumSubstanceState",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const enumSubstanceIonicState& i)
          {
            e << static_cast< const ::xml_schema::string& > (i);
          }
  
          void
          operator<< (::xercesc::DOMAttr& a, const enumSubstanceIonicState& i)
          {
            a << static_cast< const ::xml_schema::string& > (i);
          }
  
          void
          operator<< (::xml_schema::list_stream& l,
                      const enumSubstanceIonicState& i)
          {
            l << static_cast< const ::xml_schema::string& > (i);
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, enumSubstanceIonicState >
          _xsd_enumSubstanceIonicState_type_serializer_init (
            "enumSubstanceIonicState",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const enumSubstanceBindingProtein& i)
          {
            e << static_cast< const ::xml_schema::string& > (i);
          }
  
          void
          operator<< (::xercesc::DOMAttr& a, const enumSubstanceBindingProtein& i)
          {
            a << static_cast< const ::xml_schema::string& > (i);
          }
  
          void
          operator<< (::xml_schema::list_stream& l,
                      const enumSubstanceBindingProtein& i)
          {
            l << static_cast< const ::xml_schema::string& > (i);
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, enumSubstanceBindingProtein >
          _xsd_enumSubstanceBindingProtein_type_serializer_init (
            "enumSubstanceBindingProtein",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const enumCharge& i)
          {
            e << static_cast< const ::xml_schema::string& > (i);
          }
  
          void
          operator<< (::xercesc::DOMAttr& a, const enumCharge& i)
          {
            a << static_cast< const ::xml_schema::string& > (i);
          }
  
          void
          operator<< (::xml_schema::list_stream& l,
                      const enumCharge& i)
          {
            l << static_cast< const ::xml_schema::string& > (i);
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, enumCharge >
          _xsd_enumCharge_type_serializer_init (
            "enumCharge",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const enumSubstanceClass& i)
          {
            e << static_cast< const ::xml_schema::string& > (i);
          }
  
          void
          operator<< (::xercesc::DOMAttr& a, const enumSubstanceClass& i)
          {
            a << static_cast< const ::xml_schema::string& > (i);
          }
  
          void
          operator<< (::xml_schema::list_stream& l,
                      const enumSubstanceClass& i)
          {
            l << static_cast< const ::xml_schema::string& > (i);
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, enumSubstanceClass >
          _xsd_enumSubstanceClass_type_serializer_init (
            "enumSubstanceClass",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const SubstanceAerosolizationData& i)
          {
            e << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            // BronchioleModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstanceAerosolizationData::BronchioleModifier_type& x (i.BronchioleModifier ());
              if (typeid (SubstanceAerosolizationData::BronchioleModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "BronchioleModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "BronchioleModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // InflammationCoefficient
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstanceAerosolizationData::InflammationCoefficient_type& x (i.InflammationCoefficient ());
              if (typeid (SubstanceAerosolizationData::InflammationCoefficient_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "InflammationCoefficient",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "InflammationCoefficient",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // ParticulateSizeDistribution
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstanceAerosolizationData::ParticulateSizeDistribution_type& x (i.ParticulateSizeDistribution ());
              if (typeid (SubstanceAerosolizationData::ParticulateSizeDistribution_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "ParticulateSizeDistribution",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "ParticulateSizeDistribution",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, SubstanceAerosolizationData >
          _xsd_SubstanceAerosolizationData_type_serializer_init (
            "SubstanceAerosolizationData",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const SubstancePharmacokineticsData& i)
          {
            e << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            // Physicochemicals
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.Physicochemicals ())
              {
                const SubstancePharmacokineticsData::Physicochemicals_type& x (*i.Physicochemicals ());
                if (typeid (SubstancePharmacokineticsData::Physicochemicals_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "Physicochemicals",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "Physicochemicals",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // TissueKinetics
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              for (SubstancePharmacokineticsData::TissueKinetics_const_iterator
                   b (i.TissueKinetics ().begin ()), n (i.TissueKinetics ().end ());
                   b != n; ++b)
              {
                if (typeid (SubstancePharmacokineticsData::TissueKinetics_type) == typeid (*b))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "TissueKinetics",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << *b;
                }
                else
                  tsm.serialize (
                    "TissueKinetics",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, *b);
              }
            }
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, SubstancePharmacokineticsData >
          _xsd_SubstancePharmacokineticsData_type_serializer_init (
            "SubstancePharmacokineticsData",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const SubstancePhysicochemicalData& i)
          {
            e << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            // AcidDissociationConstant
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              for (SubstancePhysicochemicalData::AcidDissociationConstant_const_iterator
                   b (i.AcidDissociationConstant ().begin ()), n (i.AcidDissociationConstant ().end ());
                   b != n; ++b)
              {
                if (typeid (SubstancePhysicochemicalData::AcidDissociationConstant_type) == typeid (*b))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "AcidDissociationConstant",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << *b;
                }
                else
                  tsm.serialize (
                    "AcidDissociationConstant",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, *b);
              }
            }
  
            // BindingProtein
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePhysicochemicalData::BindingProtein_type& x (i.BindingProtein ());
              if (typeid (SubstancePhysicochemicalData::BindingProtein_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "BindingProtein",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "BindingProtein",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // BloodPlasmaRatio
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePhysicochemicalData::BloodPlasmaRatio_type& x (i.BloodPlasmaRatio ());
              if (typeid (SubstancePhysicochemicalData::BloodPlasmaRatio_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "BloodPlasmaRatio",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "BloodPlasmaRatio",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // FractionUnboundInPlasma
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePhysicochemicalData::FractionUnboundInPlasma_type& x (i.FractionUnboundInPlasma ());
              if (typeid (SubstancePhysicochemicalData::FractionUnboundInPlasma_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "FractionUnboundInPlasma",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "FractionUnboundInPlasma",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // IonicState
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePhysicochemicalData::IonicState_type& x (i.IonicState ());
              if (typeid (SubstancePhysicochemicalData::IonicState_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "IonicState",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "IonicState",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // LogP
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePhysicochemicalData::LogP_type& x (i.LogP ());
              if (typeid (SubstancePhysicochemicalData::LogP_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "LogP",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "LogP",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // HydrogenBondCount
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.HydrogenBondCount ())
              {
                const SubstancePhysicochemicalData::HydrogenBondCount_type& x (*i.HydrogenBondCount ());
                if (typeid (SubstancePhysicochemicalData::HydrogenBondCount_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "HydrogenBondCount",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "HydrogenBondCount",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // PolarSurfaceArea
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.PolarSurfaceArea ())
              {
                const SubstancePhysicochemicalData::PolarSurfaceArea_type& x (*i.PolarSurfaceArea ());
                if (typeid (SubstancePhysicochemicalData::PolarSurfaceArea_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "PolarSurfaceArea",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "PolarSurfaceArea",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, SubstancePhysicochemicalData >
          _xsd_SubstancePhysicochemicalData_type_serializer_init (
            "SubstancePhysicochemicalData",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const SubstanceTissuePharmacokineticsData& i)
          {
            e << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            // Name
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstanceTissuePharmacokineticsData::Name_type& x (i.Name ());
              if (typeid (SubstanceTissuePharmacokineticsData::Name_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "Name",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "Name",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // PartitionCoefficient
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.PartitionCoefficient ())
              {
                const SubstanceTissuePharmacokineticsData::PartitionCoefficient_type& x (*i.PartitionCoefficient ());
                if (typeid (SubstanceTissuePharmacokineticsData::PartitionCoefficient_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "PartitionCoefficient",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "PartitionCoefficient",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, SubstanceTissuePharmacokineticsData >
          _xsd_SubstanceTissuePharmacokineticsData_type_serializer_init (
            "SubstanceTissuePharmacokineticsData",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const SubstancePharmacodynamicsData& i)
          {
            e << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            // EffectSiteRateConstant
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::EffectSiteRateConstant_type& x (i.EffectSiteRateConstant ());
              if (typeid (SubstancePharmacodynamicsData::EffectSiteRateConstant_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "EffectSiteRateConstant",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "EffectSiteRateConstant",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // EMaxShapeParameter
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::EMaxShapeParameter_type& x (i.EMaxShapeParameter ());
              if (typeid (SubstancePharmacodynamicsData::EMaxShapeParameter_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "EMaxShapeParameter",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "EMaxShapeParameter",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // AntibacterialEffect
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::AntibacterialEffect_type& x (i.AntibacterialEffect ());
              if (typeid (SubstancePharmacodynamicsData::AntibacterialEffect_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "AntibacterialEffect",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "AntibacterialEffect",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // Bronchodilation
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::Bronchodilation_type& x (i.Bronchodilation ());
              if (typeid (SubstancePharmacodynamicsData::Bronchodilation_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "Bronchodilation",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "Bronchodilation",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // CentralNervousModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::CentralNervousModifier_type& x (i.CentralNervousModifier ());
              if (typeid (SubstancePharmacodynamicsData::CentralNervousModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "CentralNervousModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "CentralNervousModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // DiastolicPressureModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::DiastolicPressureModifier_type& x (i.DiastolicPressureModifier ());
              if (typeid (SubstancePharmacodynamicsData::DiastolicPressureModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "DiastolicPressureModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "DiastolicPressureModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // FeverModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::FeverModifier_type& x (i.FeverModifier ());
              if (typeid (SubstancePharmacodynamicsData::FeverModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "FeverModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "FeverModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // HeartRateModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::HeartRateModifier_type& x (i.HeartRateModifier ());
              if (typeid (SubstancePharmacodynamicsData::HeartRateModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "HeartRateModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "HeartRateModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // HemorrhageModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::HemorrhageModifier_type& x (i.HemorrhageModifier ());
              if (typeid (SubstancePharmacodynamicsData::HemorrhageModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "HemorrhageModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "HemorrhageModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // NeuromuscularBlock
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::NeuromuscularBlock_type& x (i.NeuromuscularBlock ());
              if (typeid (SubstancePharmacodynamicsData::NeuromuscularBlock_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "NeuromuscularBlock",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "NeuromuscularBlock",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // PainModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::PainModifier_type& x (i.PainModifier ());
              if (typeid (SubstancePharmacodynamicsData::PainModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "PainModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "PainModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // PupilReactivityModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::PupilReactivityModifier_type& x (i.PupilReactivityModifier ());
              if (typeid (SubstancePharmacodynamicsData::PupilReactivityModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "PupilReactivityModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "PupilReactivityModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // PupilSizeModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::PupilSizeModifier_type& x (i.PupilSizeModifier ());
              if (typeid (SubstancePharmacodynamicsData::PupilSizeModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "PupilSizeModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "PupilSizeModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // RespirationRateModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::RespirationRateModifier_type& x (i.RespirationRateModifier ());
              if (typeid (SubstancePharmacodynamicsData::RespirationRateModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "RespirationRateModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "RespirationRateModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // Sedation
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::Sedation_type& x (i.Sedation ());
              if (typeid (SubstancePharmacodynamicsData::Sedation_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "Sedation",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "Sedation",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // SystolicPressureModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::SystolicPressureModifier_type& x (i.SystolicPressureModifier ());
              if (typeid (SubstancePharmacodynamicsData::SystolicPressureModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "SystolicPressureModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "SystolicPressureModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // TidalVolumeModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::TidalVolumeModifier_type& x (i.TidalVolumeModifier ());
              if (typeid (SubstancePharmacodynamicsData::TidalVolumeModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "TidalVolumeModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "TidalVolumeModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // TubularPermeabilityModifier
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstancePharmacodynamicsData::TubularPermeabilityModifier_type& x (i.TubularPermeabilityModifier ());
              if (typeid (SubstancePharmacodynamicsData::TubularPermeabilityModifier_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "TubularPermeabilityModifier",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "TubularPermeabilityModifier",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, SubstancePharmacodynamicsData >
          _xsd_SubstancePharmacodynamicsData_type_serializer_init (
            "SubstancePharmacodynamicsData",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const SubstanceClearanceData& i)
          {
            e << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            // Systemic
            //
            if (i.Systemic ())
            {
              ::xercesc::DOMElement& s (
                ::xsd::cxx::xml::dom::create_element (
                  "Systemic",
                  "uri:/mil/tatrc/physiology/datamodel",
                  e));
  
              s << *i.Systemic ();
            }
  
            // RenalDynamics
            //
            if (i.RenalDynamics ())
            {
              ::xercesc::DOMElement& s (
                ::xsd::cxx::xml::dom::create_element (
                  "RenalDynamics",
                  "uri:/mil/tatrc/physiology/datamodel",
                  e));
  
              s << *i.RenalDynamics ();
            }
  
            // CellRegulation
            //
            if (i.CellRegulation ())
            {
              ::xercesc::DOMElement& s (
                ::xsd::cxx::xml::dom::create_element (
                  "CellRegulation",
                  "uri:/mil/tatrc/physiology/datamodel",
                  e));
  
              s << *i.CellRegulation ();
            }
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, SubstanceClearanceData >
          _xsd_SubstanceClearanceData_type_serializer_init (
            "SubstanceClearanceData",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const SubstanceData& i)
          {
            e << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            // Name
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstanceData::Name_type& x (i.Name ());
              if (typeid (SubstanceData::Name_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "Name",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "Name",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // Classification
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.Classification ())
              {
                const SubstanceData::Classification_type& x (*i.Classification ());
                if (typeid (SubstanceData::Classification_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "Classification",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "Classification",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // Density
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.Density ())
              {
                const SubstanceData::Density_type& x (*i.Density ());
                if (typeid (SubstanceData::Density_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "Density",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "Density",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // MolarMass
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.MolarMass ())
              {
                const SubstanceData::MolarMass_type& x (*i.MolarMass ());
                if (typeid (SubstanceData::MolarMass_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "MolarMass",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "MolarMass",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // State
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.State ())
              {
                const SubstanceData::State_type& x (*i.State ());
                if (typeid (SubstanceData::State_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "State",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "State",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // MaximumDiffusionFlux
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.MaximumDiffusionFlux ())
              {
                const SubstanceData::MaximumDiffusionFlux_type& x (*i.MaximumDiffusionFlux ());
                if (typeid (SubstanceData::MaximumDiffusionFlux_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "MaximumDiffusionFlux",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "MaximumDiffusionFlux",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // MichaelisCoefficient
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.MichaelisCoefficient ())
              {
                const SubstanceData::MichaelisCoefficient_type& x (*i.MichaelisCoefficient ());
                if (typeid (SubstanceData::MichaelisCoefficient_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "MichaelisCoefficient",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "MichaelisCoefficient",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // MembraneResistance
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.MembraneResistance ())
              {
                const SubstanceData::MembraneResistance_type& x (*i.MembraneResistance ());
                if (typeid (SubstanceData::MembraneResistance_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "MembraneResistance",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "MembraneResistance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // Aerosolization
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.Aerosolization ())
              {
                const SubstanceData::Aerosolization_type& x (*i.Aerosolization ());
                if (typeid (SubstanceData::Aerosolization_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "Aerosolization",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "Aerosolization",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // AreaUnderCurve
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.AreaUnderCurve ())
              {
                const SubstanceData::AreaUnderCurve_type& x (*i.AreaUnderCurve ());
                if (typeid (SubstanceData::AreaUnderCurve_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "AreaUnderCurve",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "AreaUnderCurve",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // BloodConcentration
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.BloodConcentration ())
              {
                const SubstanceData::BloodConcentration_type& x (*i.BloodConcentration ());
                if (typeid (SubstanceData::BloodConcentration_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "BloodConcentration",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "BloodConcentration",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // EffectSiteConcentration
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.EffectSiteConcentration ())
              {
                const SubstanceData::EffectSiteConcentration_type& x (*i.EffectSiteConcentration ());
                if (typeid (SubstanceData::EffectSiteConcentration_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "EffectSiteConcentration",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "EffectSiteConcentration",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // MassInBody
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.MassInBody ())
              {
                const SubstanceData::MassInBody_type& x (*i.MassInBody ());
                if (typeid (SubstanceData::MassInBody_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "MassInBody",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "MassInBody",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // MassInBlood
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.MassInBlood ())
              {
                const SubstanceData::MassInBlood_type& x (*i.MassInBlood ());
                if (typeid (SubstanceData::MassInBlood_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "MassInBlood",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "MassInBlood",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // MassInTissue
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.MassInTissue ())
              {
                const SubstanceData::MassInTissue_type& x (*i.MassInTissue ());
                if (typeid (SubstanceData::MassInTissue_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "MassInTissue",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "MassInTissue",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // PlasmaConcentration
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.PlasmaConcentration ())
              {
                const SubstanceData::PlasmaConcentration_type& x (*i.PlasmaConcentration ());
                if (typeid (SubstanceData::PlasmaConcentration_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "PlasmaConcentration",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "PlasmaConcentration",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // SystemicMassCleared
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.SystemicMassCleared ())
              {
                const SubstanceData::SystemicMassCleared_type& x (*i.SystemicMassCleared ());
                if (typeid (SubstanceData::SystemicMassCleared_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "SystemicMassCleared",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "SystemicMassCleared",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // TissueConcentration
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.TissueConcentration ())
              {
                const SubstanceData::TissueConcentration_type& x (*i.TissueConcentration ());
                if (typeid (SubstanceData::TissueConcentration_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "TissueConcentration",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "TissueConcentration",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // AlveolarTransfer
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.AlveolarTransfer ())
              {
                const SubstanceData::AlveolarTransfer_type& x (*i.AlveolarTransfer ());
                if (typeid (SubstanceData::AlveolarTransfer_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "AlveolarTransfer",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "AlveolarTransfer",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // DiffusingCapacity
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.DiffusingCapacity ())
              {
                const SubstanceData::DiffusingCapacity_type& x (*i.DiffusingCapacity ());
                if (typeid (SubstanceData::DiffusingCapacity_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "DiffusingCapacity",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "DiffusingCapacity",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // EndTidalFraction
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.EndTidalFraction ())
              {
                const SubstanceData::EndTidalFraction_type& x (*i.EndTidalFraction ());
                if (typeid (SubstanceData::EndTidalFraction_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "EndTidalFraction",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "EndTidalFraction",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // EndTidalPressure
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.EndTidalPressure ())
              {
                const SubstanceData::EndTidalPressure_type& x (*i.EndTidalPressure ());
                if (typeid (SubstanceData::EndTidalPressure_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "EndTidalPressure",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "EndTidalPressure",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // RelativeDiffusionCoefficient
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.RelativeDiffusionCoefficient ())
              {
                const SubstanceData::RelativeDiffusionCoefficient_type& x (*i.RelativeDiffusionCoefficient ());
                if (typeid (SubstanceData::RelativeDiffusionCoefficient_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "RelativeDiffusionCoefficient",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "RelativeDiffusionCoefficient",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // SolubilityCoefficient
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.SolubilityCoefficient ())
              {
                const SubstanceData::SolubilityCoefficient_type& x (*i.SolubilityCoefficient ());
                if (typeid (SubstanceData::SolubilityCoefficient_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "SolubilityCoefficient",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "SolubilityCoefficient",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // Clearance
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.Clearance ())
              {
                const SubstanceData::Clearance_type& x (*i.Clearance ());
                if (typeid (SubstanceData::Clearance_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "Clearance",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "Clearance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // Pharmacokinetics
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.Pharmacokinetics ())
              {
                const SubstanceData::Pharmacokinetics_type& x (*i.Pharmacokinetics ());
                if (typeid (SubstanceData::Pharmacokinetics_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "Pharmacokinetics",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "Pharmacokinetics",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // Pharmacodynamics
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.Pharmacodynamics ())
              {
                const SubstanceData::Pharmacodynamics_type& x (*i.Pharmacodynamics ());
                if (typeid (SubstanceData::Pharmacodynamics_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "Pharmacodynamics",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "Pharmacodynamics",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, SubstanceData >
          _xsd_SubstanceData_type_serializer_init (
            "SubstanceData",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          Substance (::std::ostream& o,
                     const ::mil::tatrc::physiology::datamodel::SubstanceData& s,
                     const ::xml_schema::namespace_infomap& m,
                     const ::std::string& e,
                     ::xml_schema::flags f)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0);
  
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::Substance (s, m, f));
  
            ::xsd::cxx::tree::error_handler< char > h;
  
            ::xsd::cxx::xml::dom::ostream_format_target t (o);
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
            }
          }
  
          void
          Substance (::std::ostream& o,
                     const ::mil::tatrc::physiology::datamodel::SubstanceData& s,
                     ::xml_schema::error_handler& h,
                     const ::xml_schema::namespace_infomap& m,
                     const ::std::string& e,
                     ::xml_schema::flags f)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0);
  
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::Substance (s, m, f));
            ::xsd::cxx::xml::dom::ostream_format_target t (o);
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              throw ::xsd::cxx::tree::serialization< char > ();
            }
          }
  
          void
          Substance (::std::ostream& o,
                     const ::mil::tatrc::physiology::datamodel::SubstanceData& s,
                     ::xercesc::DOMErrorHandler& h,
                     const ::xml_schema::namespace_infomap& m,
                     const ::std::string& e,
                     ::xml_schema::flags f)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::Substance (s, m, f));
            ::xsd::cxx::xml::dom::ostream_format_target t (o);
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              throw ::xsd::cxx::tree::serialization< char > ();
            }
          }
  
          void
          Substance (::xercesc::XMLFormatTarget& t,
                     const ::mil::tatrc::physiology::datamodel::SubstanceData& s,
                     const ::xml_schema::namespace_infomap& m,
                     const ::std::string& e,
                     ::xml_schema::flags f)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::Substance (s, m, f));
  
            ::xsd::cxx::tree::error_handler< char > h;
  
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
            }
          }
  
          void
          Substance (::xercesc::XMLFormatTarget& t,
                     const ::mil::tatrc::physiology::datamodel::SubstanceData& s,
                     ::xml_schema::error_handler& h,
                     const ::xml_schema::namespace_infomap& m,
                     const ::std::string& e,
                     ::xml_schema::flags f)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::Substance (s, m, f));
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              throw ::xsd::cxx::tree::serialization< char > ();
            }
          }
  
          void
          Substance (::xercesc::XMLFormatTarget& t,
                     const ::mil::tatrc::physiology::datamodel::SubstanceData& s,
                     ::xercesc::DOMErrorHandler& h,
                     const ::xml_schema::namespace_infomap& m,
                     const ::std::string& e,
                     ::xml_schema::flags f)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::Substance (s, m, f));
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              throw ::xsd::cxx::tree::serialization< char > ();
            }
          }
  
          void
          Substance (::xercesc::DOMDocument& d,
                     const ::mil::tatrc::physiology::datamodel::SubstanceData& s,
                     ::xml_schema::flags)
          {
            ::xercesc::DOMElement& e (*d.getDocumentElement ());
            const ::xsd::cxx::xml::qualified_name< char > n (
              ::xsd::cxx::xml::dom::name< char > (e));
  
            if (typeid (::mil::tatrc::physiology::datamodel::SubstanceData) == typeid (s))
            {
              if (n.name () == "Substance" &&
                  n.namespace_ () == "uri:/mil/tatrc/physiology/datamodel")
              {
                e << s;
              }
              else
              {
                throw ::xsd::cxx::tree::unexpected_element < char > (
                  n.name (),
                  n.namespace_ (),
                  "Substance",
                  "uri:/mil/tatrc/physiology/datamodel");
              }
            }
            else
            {
              ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ().serialize (
                "Substance",
                "uri:/mil/tatrc/physiology/datamodel",
                e, n, s);
            }
          }
  
          ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
          Substance (const ::mil::tatrc::physiology::datamodel::SubstanceData& s,
                     const ::xml_schema::namespace_infomap& m,
                     ::xml_schema::flags f)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d;
  
            if (typeid (::mil::tatrc::physiology::datamodel::SubstanceData) == typeid (s))
            {
              d = ::xsd::cxx::xml::dom::serialize< char > (
                "Substance",
                "uri:/mil/tatrc/physiology/datamodel",
                m, f);
            }
            else
            {
              d = ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ().serialize (
                "Substance",
                "uri:/mil/tatrc/physiology/datamodel",
                m, s, f);
            }
  
            ::mil::tatrc::physiology::datamodel::Substance (*d, s, f);
            return d;
          }
  
          void
          operator<< (::xercesc::DOMElement& e, const SubstanceCompoundData& i)
          {
            e << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            // Name
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstanceCompoundData::Name_type& x (i.Name ());
              if (typeid (SubstanceCompoundData::Name_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "Name",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "Name",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // Classification
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.Classification ())
              {
                const SubstanceCompoundData::Classification_type& x (*i.Classification ());
                if (typeid (SubstanceCompoundData::Classification_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "Classification",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "Classification",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // BloodRHFactor
            //
            if (i.BloodRHFactor ())
            {
              ::xercesc::DOMElement& s (
                ::xsd::cxx::xml::dom::create_element (
                  "BloodRHFactor",
                  "uri:/mil/tatrc/physiology/datamodel",
                  e));
  
              s << *i.BloodRHFactor ();
            }
  
            // Component
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              for (SubstanceCompoundData::Component_const_iterator
                   b (i.Component ().begin ()), n (i.Component ().end ());
                   b != n; ++b)
              {
                if (typeid (SubstanceCompoundData::Component_type) == typeid (*b))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "Component",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << *b;
                }
                else
                  tsm.serialize (
                    "Component",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, *b);
              }
            }
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, SubstanceCompoundData >
          _xsd_SubstanceCompoundData_type_serializer_init (
            "SubstanceCompoundData",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          SubstanceCompound (::std::ostream& o,
                             const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& s,
                             const ::xml_schema::namespace_infomap& m,
                             const ::std::string& e,
                             ::xml_schema::flags f)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0);
  
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (s, m, f));
  
            ::xsd::cxx::tree::error_handler< char > h;
  
            ::xsd::cxx::xml::dom::ostream_format_target t (o);
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
            }
          }
  
          void
          SubstanceCompound (::std::ostream& o,
                             const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& s,
                             ::xml_schema::error_handler& h,
                             const ::xml_schema::namespace_infomap& m,
                             const ::std::string& e,
                             ::xml_schema::flags f)
          {
            ::xsd::cxx::xml::auto_initializer i (
              (f & ::xml_schema::flags::dont_initialize) == 0);
  
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (s, m, f));
            ::xsd::cxx::xml::dom::ostream_format_target t (o);
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              throw ::xsd::cxx::tree::serialization< char > ();
            }
          }
  
          void
          SubstanceCompound (::std::ostream& o,
                             const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& s,
                             ::xercesc::DOMErrorHandler& h,
                             const ::xml_schema::namespace_infomap& m,
                             const ::std::string& e,
                             ::xml_schema::flags f)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (s, m, f));
            ::xsd::cxx::xml::dom::ostream_format_target t (o);
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              throw ::xsd::cxx::tree::serialization< char > ();
            }
          }
  
          void
          SubstanceCompound (::xercesc::XMLFormatTarget& t,
                             const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& s,
                             const ::xml_schema::namespace_infomap& m,
                             const ::std::string& e,
                             ::xml_schema::flags f)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (s, m, f));
  
            ::xsd::cxx::tree::error_handler< char > h;
  
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              h.throw_if_failed< ::xsd::cxx::tree::serialization< char > > ();
            }
          }
  
          void
          SubstanceCompound (::xercesc::XMLFormatTarget& t,
                             const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& s,
                             ::xml_schema::error_handler& h,
                             const ::xml_schema::namespace_infomap& m,
                             const ::std::string& e,
                             ::xml_schema::flags f)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (s, m, f));
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              throw ::xsd::cxx::tree::serialization< char > ();
            }
          }
  
          void
          SubstanceCompound (::xercesc::XMLFormatTarget& t,
                             const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& s,
                             ::xercesc::DOMErrorHandler& h,
                             const ::xml_schema::namespace_infomap& m,
                             const ::std::string& e,
                             ::xml_schema::flags f)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d (
              ::mil::tatrc::physiology::datamodel::SubstanceCompound (s, m, f));
            if (!::xsd::cxx::xml::dom::serialize (t, *d, e, h, f))
            {
              throw ::xsd::cxx::tree::serialization< char > ();
            }
          }
  
          void
          SubstanceCompound (::xercesc::DOMDocument& d,
                             const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& s,
                             ::xml_schema::flags)
          {
            ::xercesc::DOMElement& e (*d.getDocumentElement ());
            const ::xsd::cxx::xml::qualified_name< char > n (
              ::xsd::cxx::xml::dom::name< char > (e));
  
            if (typeid (::mil::tatrc::physiology::datamodel::SubstanceCompoundData) == typeid (s))
            {
              if (n.name () == "SubstanceCompound" &&
                  n.namespace_ () == "uri:/mil/tatrc/physiology/datamodel")
              {
                e << s;
              }
              else
              {
                throw ::xsd::cxx::tree::unexpected_element < char > (
                  n.name (),
                  n.namespace_ (),
                  "SubstanceCompound",
                  "uri:/mil/tatrc/physiology/datamodel");
              }
            }
            else
            {
              ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ().serialize (
                "SubstanceCompound",
                "uri:/mil/tatrc/physiology/datamodel",
                e, n, s);
            }
          }
  
          ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
          SubstanceCompound (const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& s,
                             const ::xml_schema::namespace_infomap& m,
                             ::xml_schema::flags f)
          {
            ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d;
  
            if (typeid (::mil::tatrc::physiology::datamodel::SubstanceCompoundData) == typeid (s))
            {
              d = ::xsd::cxx::xml::dom::serialize< char > (
                "SubstanceCompound",
                "uri:/mil/tatrc/physiology/datamodel",
                m, f);
            }
            else
            {
              d = ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ().serialize (
                "SubstanceCompound",
                "uri:/mil/tatrc/physiology/datamodel",
                m, s, f);
            }
  
            ::mil::tatrc::physiology::datamodel::SubstanceCompound (*d, s, f);
            return d;
          }
  
          void
          operator<< (::xercesc::DOMElement& e, const SubstanceFractionData& i)
          {
            e << static_cast< const ::xml_schema::type& > (i);
  
            // FractionAmount
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstanceFractionData::FractionAmount_type& x (i.FractionAmount ());
              if (typeid (SubstanceFractionData::FractionAmount_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "FractionAmount",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "FractionAmount",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // Name
            //
            {
              ::xercesc::DOMAttr& a (
                ::xsd::cxx::xml::dom::create_attribute (
                  "Name",
                  e));
  
              a << i.Name ();
            }
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, SubstanceFractionData >
          _xsd_SubstanceFractionData_type_serializer_init (
            "SubstanceFractionData",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const SubstanceConcentrationData& i)
          {
            e << static_cast< const ::xml_schema::type& > (i);
  
            // Concentration
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const SubstanceConcentrationData::Concentration_type& x (i.Concentration ());
              if (typeid (SubstanceConcentrationData::Concentration_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "Concentration",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "Concentration",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // Name
            //
            {
              ::xercesc::DOMAttr& a (
                ::xsd::cxx::xml::dom::create_attribute (
                  "Name",
                  e));
  
              a << i.Name ();
            }
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, SubstanceConcentrationData >
          _xsd_SubstanceConcentrationData_type_serializer_init (
            "SubstanceConcentrationData",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const PharmacodynamicModifierData& i)
          {
            e << static_cast< const ::mil::tatrc::physiology::datamodel::ObjectData& > (i);
  
            // EMax
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const PharmacodynamicModifierData::EMax_type& x (i.EMax ());
              if (typeid (PharmacodynamicModifierData::EMax_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "EMax",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "EMax",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // EC50
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const PharmacodynamicModifierData::EC50_type& x (i.EC50 ());
              if (typeid (PharmacodynamicModifierData::EC50_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "EC50",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "EC50",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
          }
  
          static
          const ::xsd::cxx::tree::type_serializer_initializer< 0, char, PharmacodynamicModifierData >
          _xsd_PharmacodynamicModifierData_type_serializer_init (
            "PharmacodynamicModifierData",
            "uri:/mil/tatrc/physiology/datamodel");
  
  
          void
          operator<< (::xercesc::DOMElement& e, const Systemic& i)
          {
            e << static_cast< const ::xml_schema::type& > (i);
  
            // FractionExcretedInFeces
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const Systemic::FractionExcretedInFeces_type& x (i.FractionExcretedInFeces ());
              if (typeid (Systemic::FractionExcretedInFeces_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "FractionExcretedInFeces",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "FractionExcretedInFeces",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // FractionExcretedInUrine
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.FractionExcretedInUrine ())
              {
                const Systemic::FractionExcretedInUrine_type& x (*i.FractionExcretedInUrine ());
                if (typeid (Systemic::FractionExcretedInUrine_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "FractionExcretedInUrine",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "FractionExcretedInUrine",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // FractionMetabolizedInGut
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.FractionMetabolizedInGut ())
              {
                const Systemic::FractionMetabolizedInGut_type& x (*i.FractionMetabolizedInGut ());
                if (typeid (Systemic::FractionMetabolizedInGut_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "FractionMetabolizedInGut",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "FractionMetabolizedInGut",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // FractionUnboundInPlasma
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const Systemic::FractionUnboundInPlasma_type& x (i.FractionUnboundInPlasma ());
              if (typeid (Systemic::FractionUnboundInPlasma_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "FractionUnboundInPlasma",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "FractionUnboundInPlasma",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // IntrinsicClearance
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const Systemic::IntrinsicClearance_type& x (i.IntrinsicClearance ());
              if (typeid (Systemic::IntrinsicClearance_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "IntrinsicClearance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "IntrinsicClearance",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // RenalClearance
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const Systemic::RenalClearance_type& x (i.RenalClearance ());
              if (typeid (Systemic::RenalClearance_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "RenalClearance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "RenalClearance",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // SystemicClearance
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const Systemic::SystemicClearance_type& x (i.SystemicClearance ());
              if (typeid (Systemic::SystemicClearance_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "SystemicClearance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "SystemicClearance",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
          }
  
          void
          operator<< (::xercesc::DOMElement& e, const RenalDynamics& i)
          {
            e << static_cast< const ::xml_schema::type& > (i);
  
            // Clearance
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.Clearance ())
              {
                const RenalDynamics::Clearance_type& x (*i.Clearance ());
                if (typeid (RenalDynamics::Clearance_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "Clearance",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "Clearance",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // Regulation
            //
            if (i.Regulation ())
            {
              ::xercesc::DOMElement& s (
                ::xsd::cxx::xml::dom::create_element (
                  "Regulation",
                  "uri:/mil/tatrc/physiology/datamodel",
                  e));
  
              s << *i.Regulation ();
            }
  
            // FiltrationRate
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.FiltrationRate ())
              {
                const RenalDynamics::FiltrationRate_type& x (*i.FiltrationRate ());
                if (typeid (RenalDynamics::FiltrationRate_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "FiltrationRate",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "FiltrationRate",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // ReabsorptionRate
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.ReabsorptionRate ())
              {
                const RenalDynamics::ReabsorptionRate_type& x (*i.ReabsorptionRate ());
                if (typeid (RenalDynamics::ReabsorptionRate_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "ReabsorptionRate",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "ReabsorptionRate",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // ExcretionRate
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.ExcretionRate ())
              {
                const RenalDynamics::ExcretionRate_type& x (*i.ExcretionRate ());
                if (typeid (RenalDynamics::ExcretionRate_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "ExcretionRate",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "ExcretionRate",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
  
            // GlomerularFilterability
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              if (i.GlomerularFilterability ())
              {
                const RenalDynamics::GlomerularFilterability_type& x (*i.GlomerularFilterability ());
                if (typeid (RenalDynamics::GlomerularFilterability_type) == typeid (x))
                {
                  ::xercesc::DOMElement& s (
                    ::xsd::cxx::xml::dom::create_element (
                      "GlomerularFilterability",
                      "uri:/mil/tatrc/physiology/datamodel",
                      e));
  
                  s << x;
                }
                else
                  tsm.serialize (
                    "GlomerularFilterability",
                    "uri:/mil/tatrc/physiology/datamodel",
                    false, true, e, x);
              }
            }
          }
  
          void
          operator<< (::xercesc::DOMElement& e, const CellRegulation& i)
          {
            e << static_cast< const ::xml_schema::type& > (i);
  
            // CellDeathRate
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const CellRegulation::CellDeathRate_type& x (i.CellDeathRate ());
              if (typeid (CellRegulation::CellDeathRate_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "CellDeathRate",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "CellDeathRate",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // CellBirthRate
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const CellRegulation::CellBirthRate_type& x (i.CellBirthRate ());
              if (typeid (CellRegulation::CellBirthRate_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "CellBirthRate",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "CellBirthRate",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
          }
  
          void
          operator<< (::xercesc::DOMElement& e, const Regulation& i)
          {
            e << static_cast< const ::xml_schema::type& > (i);
  
            // ChargeInBlood
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const Regulation::ChargeInBlood_type& x (i.ChargeInBlood ());
              if (typeid (Regulation::ChargeInBlood_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "ChargeInBlood",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "ChargeInBlood",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // FractionUnboundInPlasma
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const Regulation::FractionUnboundInPlasma_type& x (i.FractionUnboundInPlasma ());
              if (typeid (Regulation::FractionUnboundInPlasma_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "FractionUnboundInPlasma",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "FractionUnboundInPlasma",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // ReabsorptionRatio
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const Regulation::ReabsorptionRatio_type& x (i.ReabsorptionRatio ());
              if (typeid (Regulation::ReabsorptionRatio_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "ReabsorptionRatio",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "ReabsorptionRatio",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
  
            // TransportMaximum
            //
            {
              ::xsd::cxx::tree::type_serializer_map< char >& tsm (
                ::xsd::cxx::tree::type_serializer_map_instance< 0, char > ());
  
              const Regulation::TransportMaximum_type& x (i.TransportMaximum ());
              if (typeid (Regulation::TransportMaximum_type) == typeid (x))
              {
                ::xercesc::DOMElement& s (
                  ::xsd::cxx::xml::dom::create_element (
                    "TransportMaximum",
                    "uri:/mil/tatrc/physiology/datamodel",
                    e));
  
                s << x;
              }
              else
                tsm.serialize (
                  "TransportMaximum",
                  "uri:/mil/tatrc/physiology/datamodel",
                  false, true, e, x);
            }
          }
        }
      }
    }
  }
  
  #include <xsd/cxx/post.hxx>
  
  // Begin epilogue.
  //
  //
  // End epilogue.
  
  