Patient.hxx

// 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.
//

#ifndef D__BIOGEARS_CORE_SHARE_XSD__CDM_PATIENT_HXX
#define D__BIOGEARS_CORE_SHARE_XSD__CDM_PATIENT_HXX

#ifndef XSD_CXX11
#define XSD_CXX11
#endif

#ifndef XSD_USE_CHAR
#define XSD_USE_CHAR
#endif

#ifndef XSD_CXX_TREE_USE_CHAR
#define XSD_CXX_TREE_USE_CHAR
#endif

// Begin prologue.
//
#include <biogears/cdm-exports.h>
//
// End prologue.

#include <xsd/cxx/config.hxx>

#if (XSD_INT_VERSION != 4000000L)
#error XSD runtime version mismatch
#endif

#include <xsd/cxx/pre.hxx>

#include <xsd/cxx/xml/char-utf8.hxx>

#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/types.hxx>

#include <xsd/cxx/xml/error-handler.hxx>

#include <xsd/cxx/xml/dom/auto-ptr.hxx>

#include <xsd/cxx/tree/parsing.hxx>
#include <xsd/cxx/tree/parsing/byte.hxx>
#include <xsd/cxx/tree/parsing/unsigned-byte.hxx>
#include <xsd/cxx/tree/parsing/short.hxx>
#include <xsd/cxx/tree/parsing/unsigned-short.hxx>
#include <xsd/cxx/tree/parsing/int.hxx>
#include <xsd/cxx/tree/parsing/unsigned-int.hxx>
#include <xsd/cxx/tree/parsing/long.hxx>
#include <xsd/cxx/tree/parsing/unsigned-long.hxx>
#include <xsd/cxx/tree/parsing/boolean.hxx>
#include <xsd/cxx/tree/parsing/float.hxx>
#include <xsd/cxx/tree/parsing/double.hxx>
#include <xsd/cxx/tree/parsing/decimal.hxx>

#include <xsd/cxx/xml/dom/serialization-header.hxx>
#include <xsd/cxx/tree/serialization.hxx>
#include <xsd/cxx/tree/serialization/byte.hxx>
#include <xsd/cxx/tree/serialization/unsigned-byte.hxx>
#include <xsd/cxx/tree/serialization/short.hxx>
#include <xsd/cxx/tree/serialization/unsigned-short.hxx>
#include <xsd/cxx/tree/serialization/int.hxx>
#include <xsd/cxx/tree/serialization/unsigned-int.hxx>
#include <xsd/cxx/tree/serialization/long.hxx>
#include <xsd/cxx/tree/serialization/unsigned-long.hxx>
#include <xsd/cxx/tree/serialization/boolean.hxx>
#include <xsd/cxx/tree/serialization/float.hxx>
#include <xsd/cxx/tree/serialization/double.hxx>
#include <xsd/cxx/tree/serialization/decimal.hxx>

#include <xsd/cxx/tree/std-ostream-operators.hxx>

namespace xml_schema
{
  // anyType and anySimpleType.
  //

  typedef ::xsd::cxx::tree::type type;

  typedef ::xsd::cxx::tree::simple_type< char, type > simple_type;

  typedef ::xsd::cxx::tree::type container;


  // 8-bit
  //

  typedef signed char byte;

  typedef unsigned char unsigned_byte;


  // 16-bit
  //

  typedef short short_;

  typedef unsigned short unsigned_short;


  // 32-bit
  //

  typedef int int_;

  typedef unsigned int unsigned_int;


  // 64-bit
  //

  typedef long long long_;

  typedef unsigned long long unsigned_long;


  // Supposed to be arbitrary-length integral types.
  //

  typedef long long integer;

  typedef long long non_positive_integer;

  typedef unsigned long long non_negative_integer;

  typedef unsigned long long positive_integer;

  typedef long long negative_integer;


  // Boolean.
  //

  typedef bool boolean;


  // Floating-point types.
  //

  typedef float float_;

  typedef double double_;

  typedef double decimal;


  // String types.
  //

  typedef ::xsd::cxx::tree::string< char, simple_type > string;

  typedef ::xsd::cxx::tree::normalized_string< char, string > normalized_string;

  typedef ::xsd::cxx::tree::token< char, normalized_string > token;

  typedef ::xsd::cxx::tree::name< char, token > name;

  typedef ::xsd::cxx::tree::nmtoken< char, token > nmtoken;

  typedef ::xsd::cxx::tree::nmtokens< char, simple_type, nmtoken > nmtokens;

  typedef ::xsd::cxx::tree::ncname< char, name > ncname;

  typedef ::xsd::cxx::tree::language< char, token > language;


  // ID/IDREF.
  //

  typedef ::xsd::cxx::tree::id< char, ncname > id;

  typedef ::xsd::cxx::tree::idref< char, ncname, type > idref;

  typedef ::xsd::cxx::tree::idrefs< char, simple_type, idref > idrefs;


  // URI.
  //

  typedef ::xsd::cxx::tree::uri< char, simple_type > uri;


  // Qualified name.
  //

  typedef ::xsd::cxx::tree::qname< char, simple_type, uri, ncname > qname;


  // Binary.
  //

  typedef ::xsd::cxx::tree::buffer< char > buffer;

  typedef ::xsd::cxx::tree::base64_binary< char, simple_type > base64_binary;

  typedef ::xsd::cxx::tree::hex_binary< char, simple_type > hex_binary;


  // Date/time.
  //

  typedef ::xsd::cxx::tree::time_zone time_zone;

  typedef ::xsd::cxx::tree::date< char, simple_type > date;

  typedef ::xsd::cxx::tree::date_time< char, simple_type > date_time;

  typedef ::xsd::cxx::tree::duration< char, simple_type > duration;

  typedef ::xsd::cxx::tree::gday< char, simple_type > gday;

  typedef ::xsd::cxx::tree::gmonth< char, simple_type > gmonth;

  typedef ::xsd::cxx::tree::gmonth_day< char, simple_type > gmonth_day;

  typedef ::xsd::cxx::tree::gyear< char, simple_type > gyear;

  typedef ::xsd::cxx::tree::gyear_month< char, simple_type > gyear_month;

  typedef ::xsd::cxx::tree::time< char, simple_type > time;


  // Entity.
  //

  typedef ::xsd::cxx::tree::entity< char, ncname > entity;

  typedef ::xsd::cxx::tree::entities< char, simple_type, entity > entities;



  typedef ::xsd::cxx::tree::content_order content_order;
  // Namespace information and list stream. Used in
  // serialization functions.
  //
  typedef ::xsd::cxx::xml::dom::namespace_info< char > namespace_info;

  typedef ::xsd::cxx::xml::dom::namespace_infomap< char > namespace_infomap;

  typedef ::xsd::cxx::tree::list_stream< char > list_stream;

  typedef ::xsd::cxx::tree::as_double< double_ > as_double;

  typedef ::xsd::cxx::tree::as_decimal< decimal > as_decimal;

  typedef ::xsd::cxx::tree::facet facet;

  // Flags and properties.
  //

  typedef ::xsd::cxx::tree::flags flags;

  typedef ::xsd::cxx::tree::properties< char > properties;

  // Parsing/serialization diagnostics.
  //

  typedef ::xsd::cxx::tree::severity severity;

  typedef ::xsd::cxx::tree::error< char > error;

  typedef ::xsd::cxx::tree::diagnostics< char > diagnostics;

  // Exceptions.
  //

  typedef ::xsd::cxx::tree::exception< char > exception;

  typedef ::xsd::cxx::tree::bounds< char > bounds;

  typedef ::xsd::cxx::tree::duplicate_id< char > duplicate_id;

  typedef ::xsd::cxx::tree::parsing< char > parsing;

  typedef ::xsd::cxx::tree::expected_element< char > expected_element;

  typedef ::xsd::cxx::tree::unexpected_element< char > unexpected_element;

  typedef ::xsd::cxx::tree::expected_attribute< char > expected_attribute;

  typedef ::xsd::cxx::tree::unexpected_enumerator< char > unexpected_enumerator;

  typedef ::xsd::cxx::tree::expected_text_content< char > expected_text_content;

  typedef ::xsd::cxx::tree::no_prefix_mapping< char > no_prefix_mapping;

  typedef ::xsd::cxx::tree::no_type_info< char > no_type_info;

  typedef ::xsd::cxx::tree::not_derived< char > not_derived;

  typedef ::xsd::cxx::tree::serialization< char > serialization;

  typedef ::xsd::cxx::xml::error_handler< char > error_handler;

  namespace dom
  {
    using ::xsd::cxx::xml::dom::unique_ptr;

#ifndef XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA
#define XSD_CXX_TREE_TREE_NODE_KEY__XML_SCHEMA

    const XMLCh* const tree_node_key = ::xsd::cxx::tree::user_data_keys::node;
#endif
  }
}

// Forward declarations.
//
namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {
        class enumSex;
        class enumBloodType;
        class enumPatientEvent;
        class ActivePatientEventData;
        class PatientData;
        class NormalDistributionRangeData;
        class DiscreteDistributionRangeData;
        class BernoulliDistributionData;
        class PopulationData;
      }
    }
  }
}


#include <memory>    // ::std::unique_ptr
#include <limits>    // std::numeric_limits
#include <algorithm> // std::binary_search
#include <utility>   // std::move

#include <xsd/cxx/xml/char-utf8.hxx>

#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/containers.hxx>
#include <xsd/cxx/tree/list.hxx>

#include <xsd/cxx/xml/dom/parsing-header.hxx>

#include "properties.hxx"

namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {
        class BIOGEARS_CDM_API enumSex: public ::xml_schema::string
        {
          public:

          enum value
          {
            Male,
            Female
          };

          enumSex ();

          enumSex (value v);

          enumSex (const char* v);

          enumSex (const ::std::string& v);

          enumSex (const ::xml_schema::string& v);

          enumSex (const ::xercesc::DOMElement& e,
                   ::xml_schema::flags f = 0,
                   ::xml_schema::container* c = 0);

          enumSex (const ::xercesc::DOMAttr& a,
                   ::xml_schema::flags f = 0,
                   ::xml_schema::container* c = 0);

          enumSex (const ::std::string& s,
                   const ::xercesc::DOMElement* e,
                   ::xml_schema::flags f = 0,
                   ::xml_schema::container* c = 0);

          enumSex (const enumSex& x,
                   ::xml_schema::flags f = 0,
                   ::xml_schema::container* c = 0);

          virtual enumSex*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          enumSex&
          operator= (value v);

          virtual
          operator value () const
          {
            return _xsd_enumSex_convert ();
          }

          //@cond

          protected:
          value
          _xsd_enumSex_convert () const;

          public:
          static const char* const _xsd_enumSex_literals_[2];
          static const value _xsd_enumSex_indexes_[2];

          //@endcond
        };

        class BIOGEARS_CDM_API enumBloodType: public ::xml_schema::string
        {
          public:

          enum value
          {
            A,
            B,
            AB,
            O
          };

          enumBloodType ();

          enumBloodType (value v);

          enumBloodType (const char* v);

          enumBloodType (const ::std::string& v);

          enumBloodType (const ::xml_schema::string& v);

          enumBloodType (const ::xercesc::DOMElement& e,
                         ::xml_schema::flags f = 0,
                         ::xml_schema::container* c = 0);

          enumBloodType (const ::xercesc::DOMAttr& a,
                         ::xml_schema::flags f = 0,
                         ::xml_schema::container* c = 0);

          enumBloodType (const ::std::string& s,
                         const ::xercesc::DOMElement* e,
                         ::xml_schema::flags f = 0,
                         ::xml_schema::container* c = 0);

          enumBloodType (const enumBloodType& x,
                         ::xml_schema::flags f = 0,
                         ::xml_schema::container* c = 0);

          virtual enumBloodType*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          enumBloodType&
          operator= (value v);

          virtual
          operator value () const
          {
            return _xsd_enumBloodType_convert ();
          }

          //@cond

          protected:
          value
          _xsd_enumBloodType_convert () const;

          public:
          static const char* const _xsd_enumBloodType_literals_[4];
          static const value _xsd_enumBloodType_indexes_[4];

          //@endcond
        };

        class BIOGEARS_CDM_API enumPatientEvent: public ::xml_schema::string
        {
          public:

          enum value
          {
            AcuteLungInjury,
            AcuteRespiratoryDistress,
            Antidiuresis,
            Asystole,
            Bradycardia,
            Bradypnea,
            BrainOxygenDeficit,
            CardiacArrest,
            CardiogenicShock,
            CriticalBrainOxygenDeficit,
            Dehydration,
            Diuresis,
            Fasciculation,
            Fatigue,
            FunctionalIncontinence,
            HemolyticTransfusionReaction,
            Hypercapnia,
            Hyperglycemia,
            MildHyperkalemia,
            SevereHyperkalemia,
            MildHypernatremia,
            SevereHypernatremia,
            Hyperthermia,
            Hypoglycemia,
            HypoglycemicShock,
            HypoglycemicComa,
            Hypothermia,
            MildHypokalemia,
            SevereHypokalemia,
            MildHyponatremia,
            SevereHyponatremia,
            Hypoxia,
            HypovolemicShock,
            IntracranialHypertension,
            IntracranialHypotension,
            IrreversibleState,
            Ketoacidosis,
            LacticAcidosis,
            LiverGlycogenDepleted,
            MaximumPulmonaryVentilationRate,
            MetabolicAcidosis,
            MetabolicAlkalosis,
            MuscleCatabolism,
            MuscleGlycogenDepleted,
            MyocardiumOxygenDeficit,
            Natriuresis,
            NutritionDepleted,
            PulselessRhythm,
            RenalHypoperfusion,
            RespiratoryAcidosis,
            RespiratoryAlkalosis,
            SevereAcuteRespiratoryDistress,
            StartOfCardiacCycle,
            StartOfExhale,
            StartOfInhale,
            SevereSepsis,
            Tachycardia,
            Tachypnea,
            TotalPatientEvents
          };

          enumPatientEvent ();

          enumPatientEvent (value v);

          enumPatientEvent (const char* v);

          enumPatientEvent (const ::std::string& v);

          enumPatientEvent (const ::xml_schema::string& v);

          enumPatientEvent (const ::xercesc::DOMElement& e,
                            ::xml_schema::flags f = 0,
                            ::xml_schema::container* c = 0);

          enumPatientEvent (const ::xercesc::DOMAttr& a,
                            ::xml_schema::flags f = 0,
                            ::xml_schema::container* c = 0);

          enumPatientEvent (const ::std::string& s,
                            const ::xercesc::DOMElement* e,
                            ::xml_schema::flags f = 0,
                            ::xml_schema::container* c = 0);

          enumPatientEvent (const enumPatientEvent& x,
                            ::xml_schema::flags f = 0,
                            ::xml_schema::container* c = 0);

          virtual enumPatientEvent*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          enumPatientEvent&
          operator= (value v);

          virtual
          operator value () const
          {
            return _xsd_enumPatientEvent_convert ();
          }

          //@cond

          protected:
          value
          _xsd_enumPatientEvent_convert () const;

          public:
          static const char* const _xsd_enumPatientEvent_literals_[59];
          static const value _xsd_enumPatientEvent_indexes_[59];

          //@endcond
        };

        class BIOGEARS_CDM_API ActivePatientEventData: public ::xml_schema::type
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarTimeData Duration_type;

          typedef ::xsd::cxx::tree::traits< Duration_type, char > Duration_traits;

          const Duration_type&
          Duration () const;

          Duration_type&
          Duration ();

          void
          Duration (const Duration_type& x);

          void
          Duration (::std::unique_ptr< Duration_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumPatientEvent Event_type;

          typedef ::xsd::cxx::tree::traits< Event_type, char > Event_traits;

          const Event_type&
          Event () const;

          Event_type&
          Event ();

          void
          Event (const Event_type& x);

          void
          Event (::std::unique_ptr< Event_type > p);



          ActivePatientEventData ();

          ActivePatientEventData (const Duration_type&,
                                  const Event_type&);

          ActivePatientEventData (::std::unique_ptr< Duration_type >,
                                  const Event_type&);

          ActivePatientEventData (const ::xercesc::DOMElement& e,
                                  ::xml_schema::flags f = 0,
                                  ::xml_schema::container* c = 0);

          ActivePatientEventData (const ActivePatientEventData& x,
                                  ::xml_schema::flags f = 0,
                                  ::xml_schema::container* c = 0);

          virtual ActivePatientEventData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          ActivePatientEventData&
          operator= (const ActivePatientEventData& x);


          virtual 
          ~ActivePatientEventData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          ::xsd::cxx::tree::one< Duration_type > Duration_;
          ::xsd::cxx::tree::one< Event_type > Event_;

          //@endcond
        };

        class BIOGEARS_CDM_API PatientData: public ::mil::tatrc::physiology::datamodel::ObjectData
        {
          public:

          typedef ::xml_schema::string Annotation_type;

          typedef ::xsd::cxx::tree::optional< Annotation_type > Annotation_optional;

          typedef ::xsd::cxx::tree::traits< Annotation_type, char > Annotation_traits;

          const Annotation_optional&
          Annotation () const;

          Annotation_optional&
          Annotation ();

          void
          Annotation (const Annotation_type& x);

          void
          Annotation (const Annotation_optional& x);

          void
          Annotation (::std::unique_ptr< Annotation_type > p);



          typedef ::xml_schema::string Name_type;

          typedef ::xsd::cxx::tree::traits< Name_type, char > Name_traits;

          const Name_type&
          Name () const;

          Name_type&
          Name ();

          void
          Name (const Name_type& x);

          void
          Name (::std::unique_ptr< Name_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumSex Sex_type;

          typedef ::xsd::cxx::tree::optional< Sex_type > Sex_optional;

          typedef ::xsd::cxx::tree::traits< Sex_type, char > Sex_traits;

          const Sex_optional&
          Sex () const;

          Sex_optional&
          Sex ();

          void
          Sex (const Sex_type& x);

          void
          Sex (const Sex_optional& x);

          void
          Sex (::std::unique_ptr< Sex_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarTimeData Age_type;

          typedef ::xsd::cxx::tree::optional< Age_type > Age_optional;

          typedef ::xsd::cxx::tree::traits< Age_type, char > Age_traits;

          const Age_optional&
          Age () const;

          Age_optional&
          Age ();

          void
          Age (const Age_type& x);

          void
          Age (const Age_optional& x);

          void
          Age (::std::unique_ptr< Age_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData Weight_type;

          typedef ::xsd::cxx::tree::optional< Weight_type > Weight_optional;

          typedef ::xsd::cxx::tree::traits< Weight_type, char > Weight_traits;

          const Weight_optional&
          Weight () const;

          Weight_optional&
          Weight ();

          void
          Weight (const Weight_type& x);

          void
          Weight (const Weight_optional& x);

          void
          Weight (::std::unique_ptr< Weight_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarLengthData Height_type;

          typedef ::xsd::cxx::tree::optional< Height_type > Height_optional;

          typedef ::xsd::cxx::tree::traits< Height_type, char > Height_traits;

          const Height_optional&
          Height () const;

          Height_optional&
          Height ();

          void
          Height (const Height_type& x);

          void
          Height (const Height_optional& x);

          void
          Height (::std::unique_ptr< Height_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerVolumeData BodyDensity_type;

          typedef ::xsd::cxx::tree::optional< BodyDensity_type > BodyDensity_optional;

          typedef ::xsd::cxx::tree::traits< BodyDensity_type, char > BodyDensity_traits;

          const BodyDensity_optional&
          BodyDensity () const;

          BodyDensity_optional&
          BodyDensity ();

          void
          BodyDensity (const BodyDensity_type& x);

          void
          BodyDensity (const BodyDensity_optional& x);

          void
          BodyDensity (::std::unique_ptr< BodyDensity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFractionData BodyFatFraction_type;

          typedef ::xsd::cxx::tree::optional< BodyFatFraction_type > BodyFatFraction_optional;

          typedef ::xsd::cxx::tree::traits< BodyFatFraction_type, char > BodyFatFraction_traits;

          const BodyFatFraction_optional&
          BodyFatFraction () const;

          BodyFatFraction_optional&
          BodyFatFraction ();

          void
          BodyFatFraction (const BodyFatFraction_type& x);

          void
          BodyFatFraction (const BodyFatFraction_optional& x);

          void
          BodyFatFraction (::std::unique_ptr< BodyFatFraction_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData LeanBodyMass_type;

          typedef ::xsd::cxx::tree::optional< LeanBodyMass_type > LeanBodyMass_optional;

          typedef ::xsd::cxx::tree::traits< LeanBodyMass_type, char > LeanBodyMass_traits;

          const LeanBodyMass_optional&
          LeanBodyMass () const;

          LeanBodyMass_optional&
          LeanBodyMass ();

          void
          LeanBodyMass (const LeanBodyMass_type& x);

          void
          LeanBodyMass (const LeanBodyMass_optional& x);

          void
          LeanBodyMass (::std::unique_ptr< LeanBodyMass_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPowerData MaxWorkRate_type;

          typedef ::xsd::cxx::tree::optional< MaxWorkRate_type > MaxWorkRate_optional;

          typedef ::xsd::cxx::tree::traits< MaxWorkRate_type, char > MaxWorkRate_traits;

          const MaxWorkRate_optional&
          MaxWorkRate () const;

          MaxWorkRate_optional&
          MaxWorkRate ();

          void
          MaxWorkRate (const MaxWorkRate_type& x);

          void
          MaxWorkRate (const MaxWorkRate_optional& x);

          void
          MaxWorkRate (::std::unique_ptr< MaxWorkRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassData MuscleMass_type;

          typedef ::xsd::cxx::tree::optional< MuscleMass_type > MuscleMass_optional;

          typedef ::xsd::cxx::tree::traits< MuscleMass_type, char > MuscleMass_traits;

          const MuscleMass_optional&
          MuscleMass () const;

          MuscleMass_optional&
          MuscleMass ();

          void
          MuscleMass (const MuscleMass_type& x);

          void
          MuscleMass (const MuscleMass_optional& x);

          void
          MuscleMass (::std::unique_ptr< MuscleMass_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumBloodType BloodTypeABO_type;

          typedef ::xsd::cxx::tree::optional< BloodTypeABO_type > BloodTypeABO_optional;

          typedef ::xsd::cxx::tree::traits< BloodTypeABO_type, char > BloodTypeABO_traits;

          const BloodTypeABO_optional&
          BloodTypeABO () const;

          BloodTypeABO_optional&
          BloodTypeABO ();

          void
          BloodTypeABO (const BloodTypeABO_type& x);

          void
          BloodTypeABO (const BloodTypeABO_optional& x);

          void
          BloodTypeABO (::std::unique_ptr< BloodTypeABO_type > p);



          typedef ::xml_schema::boolean BloodTypeRh_type;

          typedef ::xsd::cxx::tree::optional< BloodTypeRh_type > BloodTypeRh_optional;

          typedef ::xsd::cxx::tree::traits< BloodTypeRh_type, char > BloodTypeRh_traits;

          const BloodTypeRh_optional&
          BloodTypeRh () const;

          BloodTypeRh_optional&
          BloodTypeRh ();

          void
          BloodTypeRh (const BloodTypeRh_type& x);

          void
          BloodTypeRh (const BloodTypeRh_optional& x);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAreaData AlveoliSurfaceArea_type;

          typedef ::xsd::cxx::tree::optional< AlveoliSurfaceArea_type > AlveoliSurfaceArea_optional;

          typedef ::xsd::cxx::tree::traits< AlveoliSurfaceArea_type, char > AlveoliSurfaceArea_traits;

          const AlveoliSurfaceArea_optional&
          AlveoliSurfaceArea () const;

          AlveoliSurfaceArea_optional&
          AlveoliSurfaceArea ();

          void
          AlveoliSurfaceArea (const AlveoliSurfaceArea_type& x);

          void
          AlveoliSurfaceArea (const AlveoliSurfaceArea_optional& x);

          void
          AlveoliSurfaceArea (::std::unique_ptr< AlveoliSurfaceArea_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarNeg1To1Data Hyperhidrosis_type;

          typedef ::xsd::cxx::tree::optional< Hyperhidrosis_type > Hyperhidrosis_optional;

          typedef ::xsd::cxx::tree::traits< Hyperhidrosis_type, char > Hyperhidrosis_traits;

          const Hyperhidrosis_optional&
          Hyperhidrosis () const;

          Hyperhidrosis_optional&
          Hyperhidrosis ();

          void
          Hyperhidrosis (const Hyperhidrosis_type& x);

          void
          Hyperhidrosis (const Hyperhidrosis_optional& x);

          void
          Hyperhidrosis (::std::unique_ptr< Hyperhidrosis_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFractionData RightLungRatio_type;

          typedef ::xsd::cxx::tree::optional< RightLungRatio_type > RightLungRatio_optional;

          typedef ::xsd::cxx::tree::traits< RightLungRatio_type, char > RightLungRatio_traits;

          const RightLungRatio_optional&
          RightLungRatio () const;

          RightLungRatio_optional&
          RightLungRatio ();

          void
          RightLungRatio (const RightLungRatio_type& x);

          void
          RightLungRatio (const RightLungRatio_optional& x);

          void
          RightLungRatio (::std::unique_ptr< RightLungRatio_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarAreaData SkinSurfaceArea_type;

          typedef ::xsd::cxx::tree::optional< SkinSurfaceArea_type > SkinSurfaceArea_optional;

          typedef ::xsd::cxx::tree::traits< SkinSurfaceArea_type, char > SkinSurfaceArea_traits;

          const SkinSurfaceArea_optional&
          SkinSurfaceArea () const;

          SkinSurfaceArea_optional&
          SkinSurfaceArea ();

          void
          SkinSurfaceArea (const SkinSurfaceArea_type& x);

          void
          SkinSurfaceArea (const SkinSurfaceArea_optional& x);

          void
          SkinSurfaceArea (::std::unique_ptr< SkinSurfaceArea_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarTimeData SleepAmount_type;

          typedef ::xsd::cxx::tree::optional< SleepAmount_type > SleepAmount_optional;

          typedef ::xsd::cxx::tree::traits< SleepAmount_type, char > SleepAmount_traits;

          const SleepAmount_optional&
          SleepAmount () const;

          SleepAmount_optional&
          SleepAmount ();

          void
          SleepAmount (const SleepAmount_type& x);

          void
          SleepAmount (const SleepAmount_optional& x);

          void
          SleepAmount (::std::unique_ptr< SleepAmount_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarNeg1To1Data PainSusceptibility_type;

          typedef ::xsd::cxx::tree::optional< PainSusceptibility_type > PainSusceptibility_optional;

          typedef ::xsd::cxx::tree::traits< PainSusceptibility_type, char > PainSusceptibility_traits;

          const PainSusceptibility_optional&
          PainSusceptibility () const;

          PainSusceptibility_optional&
          PainSusceptibility ();

          void
          PainSusceptibility (const PainSusceptibility_type& x);

          void
          PainSusceptibility (const PainSusceptibility_optional& x);

          void
          PainSusceptibility (::std::unique_ptr< PainSusceptibility_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPowerData BasalMetabolicRate_type;

          typedef ::xsd::cxx::tree::optional< BasalMetabolicRate_type > BasalMetabolicRate_optional;

          typedef ::xsd::cxx::tree::traits< BasalMetabolicRate_type, char > BasalMetabolicRate_traits;

          const BasalMetabolicRate_optional&
          BasalMetabolicRate () const;

          BasalMetabolicRate_optional&
          BasalMetabolicRate ();

          void
          BasalMetabolicRate (const BasalMetabolicRate_type& x);

          void
          BasalMetabolicRate (const BasalMetabolicRate_optional& x);

          void
          BasalMetabolicRate (::std::unique_ptr< BasalMetabolicRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData BloodVolumeBaseline_type;

          typedef ::xsd::cxx::tree::optional< BloodVolumeBaseline_type > BloodVolumeBaseline_optional;

          typedef ::xsd::cxx::tree::traits< BloodVolumeBaseline_type, char > BloodVolumeBaseline_traits;

          const BloodVolumeBaseline_optional&
          BloodVolumeBaseline () const;

          BloodVolumeBaseline_optional&
          BloodVolumeBaseline ();

          void
          BloodVolumeBaseline (const BloodVolumeBaseline_type& x);

          void
          BloodVolumeBaseline (const BloodVolumeBaseline_optional& x);

          void
          BloodVolumeBaseline (::std::unique_ptr< BloodVolumeBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData DiastolicArterialPressureBaseline_type;

          typedef ::xsd::cxx::tree::optional< DiastolicArterialPressureBaseline_type > DiastolicArterialPressureBaseline_optional;

          typedef ::xsd::cxx::tree::traits< DiastolicArterialPressureBaseline_type, char > DiastolicArterialPressureBaseline_traits;

          const DiastolicArterialPressureBaseline_optional&
          DiastolicArterialPressureBaseline () const;

          DiastolicArterialPressureBaseline_optional&
          DiastolicArterialPressureBaseline ();

          void
          DiastolicArterialPressureBaseline (const DiastolicArterialPressureBaseline_type& x);

          void
          DiastolicArterialPressureBaseline (const DiastolicArterialPressureBaseline_optional& x);

          void
          DiastolicArterialPressureBaseline (::std::unique_ptr< DiastolicArterialPressureBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFrequencyData HeartRateBaseline_type;

          typedef ::xsd::cxx::tree::optional< HeartRateBaseline_type > HeartRateBaseline_optional;

          typedef ::xsd::cxx::tree::traits< HeartRateBaseline_type, char > HeartRateBaseline_traits;

          const HeartRateBaseline_optional&
          HeartRateBaseline () const;

          HeartRateBaseline_optional&
          HeartRateBaseline ();

          void
          HeartRateBaseline (const HeartRateBaseline_type& x);

          void
          HeartRateBaseline (const HeartRateBaseline_optional& x);

          void
          HeartRateBaseline (::std::unique_ptr< HeartRateBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData MeanArterialPressureBaseline_type;

          typedef ::xsd::cxx::tree::optional< MeanArterialPressureBaseline_type > MeanArterialPressureBaseline_optional;

          typedef ::xsd::cxx::tree::traits< MeanArterialPressureBaseline_type, char > MeanArterialPressureBaseline_traits;

          const MeanArterialPressureBaseline_optional&
          MeanArterialPressureBaseline () const;

          MeanArterialPressureBaseline_optional&
          MeanArterialPressureBaseline ();

          void
          MeanArterialPressureBaseline (const MeanArterialPressureBaseline_type& x);

          void
          MeanArterialPressureBaseline (const MeanArterialPressureBaseline_optional& x);

          void
          MeanArterialPressureBaseline (::std::unique_ptr< MeanArterialPressureBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFrequencyData RespirationRateBaseline_type;

          typedef ::xsd::cxx::tree::optional< RespirationRateBaseline_type > RespirationRateBaseline_optional;

          typedef ::xsd::cxx::tree::traits< RespirationRateBaseline_type, char > RespirationRateBaseline_traits;

          const RespirationRateBaseline_optional&
          RespirationRateBaseline () const;

          RespirationRateBaseline_optional&
          RespirationRateBaseline ();

          void
          RespirationRateBaseline (const RespirationRateBaseline_type& x);

          void
          RespirationRateBaseline (const RespirationRateBaseline_optional& x);

          void
          RespirationRateBaseline (::std::unique_ptr< RespirationRateBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData SystolicArterialPressureBaseline_type;

          typedef ::xsd::cxx::tree::optional< SystolicArterialPressureBaseline_type > SystolicArterialPressureBaseline_optional;

          typedef ::xsd::cxx::tree::traits< SystolicArterialPressureBaseline_type, char > SystolicArterialPressureBaseline_traits;

          const SystolicArterialPressureBaseline_optional&
          SystolicArterialPressureBaseline () const;

          SystolicArterialPressureBaseline_optional&
          SystolicArterialPressureBaseline ();

          void
          SystolicArterialPressureBaseline (const SystolicArterialPressureBaseline_type& x);

          void
          SystolicArterialPressureBaseline (const SystolicArterialPressureBaseline_optional& x);

          void
          SystolicArterialPressureBaseline (::std::unique_ptr< SystolicArterialPressureBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData TidalVolumeBaseline_type;

          typedef ::xsd::cxx::tree::optional< TidalVolumeBaseline_type > TidalVolumeBaseline_optional;

          typedef ::xsd::cxx::tree::traits< TidalVolumeBaseline_type, char > TidalVolumeBaseline_traits;

          const TidalVolumeBaseline_optional&
          TidalVolumeBaseline () const;

          TidalVolumeBaseline_optional&
          TidalVolumeBaseline ();

          void
          TidalVolumeBaseline (const TidalVolumeBaseline_type& x);

          void
          TidalVolumeBaseline (const TidalVolumeBaseline_optional& x);

          void
          TidalVolumeBaseline (::std::unique_ptr< TidalVolumeBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFrequencyData HeartRateMaximum_type;

          typedef ::xsd::cxx::tree::optional< HeartRateMaximum_type > HeartRateMaximum_optional;

          typedef ::xsd::cxx::tree::traits< HeartRateMaximum_type, char > HeartRateMaximum_traits;

          const HeartRateMaximum_optional&
          HeartRateMaximum () const;

          HeartRateMaximum_optional&
          HeartRateMaximum ();

          void
          HeartRateMaximum (const HeartRateMaximum_type& x);

          void
          HeartRateMaximum (const HeartRateMaximum_optional& x);

          void
          HeartRateMaximum (::std::unique_ptr< HeartRateMaximum_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFrequencyData HeartRateMinimum_type;

          typedef ::xsd::cxx::tree::optional< HeartRateMinimum_type > HeartRateMinimum_optional;

          typedef ::xsd::cxx::tree::traits< HeartRateMinimum_type, char > HeartRateMinimum_traits;

          const HeartRateMinimum_optional&
          HeartRateMinimum () const;

          HeartRateMinimum_optional&
          HeartRateMinimum ();

          void
          HeartRateMinimum (const HeartRateMinimum_type& x);

          void
          HeartRateMinimum (const HeartRateMinimum_optional& x);

          void
          HeartRateMinimum (::std::unique_ptr< HeartRateMinimum_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData ExpiratoryReserveVolume_type;

          typedef ::xsd::cxx::tree::optional< ExpiratoryReserveVolume_type > ExpiratoryReserveVolume_optional;

          typedef ::xsd::cxx::tree::traits< ExpiratoryReserveVolume_type, char > ExpiratoryReserveVolume_traits;

          const ExpiratoryReserveVolume_optional&
          ExpiratoryReserveVolume () const;

          ExpiratoryReserveVolume_optional&
          ExpiratoryReserveVolume ();

          void
          ExpiratoryReserveVolume (const ExpiratoryReserveVolume_type& x);

          void
          ExpiratoryReserveVolume (const ExpiratoryReserveVolume_optional& x);

          void
          ExpiratoryReserveVolume (::std::unique_ptr< ExpiratoryReserveVolume_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData FunctionalResidualCapacity_type;

          typedef ::xsd::cxx::tree::optional< FunctionalResidualCapacity_type > FunctionalResidualCapacity_optional;

          typedef ::xsd::cxx::tree::traits< FunctionalResidualCapacity_type, char > FunctionalResidualCapacity_traits;

          const FunctionalResidualCapacity_optional&
          FunctionalResidualCapacity () const;

          FunctionalResidualCapacity_optional&
          FunctionalResidualCapacity ();

          void
          FunctionalResidualCapacity (const FunctionalResidualCapacity_type& x);

          void
          FunctionalResidualCapacity (const FunctionalResidualCapacity_optional& x);

          void
          FunctionalResidualCapacity (::std::unique_ptr< FunctionalResidualCapacity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData InspiratoryCapacity_type;

          typedef ::xsd::cxx::tree::optional< InspiratoryCapacity_type > InspiratoryCapacity_optional;

          typedef ::xsd::cxx::tree::traits< InspiratoryCapacity_type, char > InspiratoryCapacity_traits;

          const InspiratoryCapacity_optional&
          InspiratoryCapacity () const;

          InspiratoryCapacity_optional&
          InspiratoryCapacity ();

          void
          InspiratoryCapacity (const InspiratoryCapacity_type& x);

          void
          InspiratoryCapacity (const InspiratoryCapacity_optional& x);

          void
          InspiratoryCapacity (::std::unique_ptr< InspiratoryCapacity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData InspiratoryReserveVolume_type;

          typedef ::xsd::cxx::tree::optional< InspiratoryReserveVolume_type > InspiratoryReserveVolume_optional;

          typedef ::xsd::cxx::tree::traits< InspiratoryReserveVolume_type, char > InspiratoryReserveVolume_traits;

          const InspiratoryReserveVolume_optional&
          InspiratoryReserveVolume () const;

          InspiratoryReserveVolume_optional&
          InspiratoryReserveVolume ();

          void
          InspiratoryReserveVolume (const InspiratoryReserveVolume_type& x);

          void
          InspiratoryReserveVolume (const InspiratoryReserveVolume_optional& x);

          void
          InspiratoryReserveVolume (::std::unique_ptr< InspiratoryReserveVolume_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData ResidualVolume_type;

          typedef ::xsd::cxx::tree::optional< ResidualVolume_type > ResidualVolume_optional;

          typedef ::xsd::cxx::tree::traits< ResidualVolume_type, char > ResidualVolume_traits;

          const ResidualVolume_optional&
          ResidualVolume () const;

          ResidualVolume_optional&
          ResidualVolume ();

          void
          ResidualVolume (const ResidualVolume_type& x);

          void
          ResidualVolume (const ResidualVolume_optional& x);

          void
          ResidualVolume (::std::unique_ptr< ResidualVolume_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarPressureData RespiratoryDriverAmplitudeBaseline_type;

          typedef ::xsd::cxx::tree::optional< RespiratoryDriverAmplitudeBaseline_type > RespiratoryDriverAmplitudeBaseline_optional;

          typedef ::xsd::cxx::tree::traits< RespiratoryDriverAmplitudeBaseline_type, char > RespiratoryDriverAmplitudeBaseline_traits;

          const RespiratoryDriverAmplitudeBaseline_optional&
          RespiratoryDriverAmplitudeBaseline () const;

          RespiratoryDriverAmplitudeBaseline_optional&
          RespiratoryDriverAmplitudeBaseline ();

          void
          RespiratoryDriverAmplitudeBaseline (const RespiratoryDriverAmplitudeBaseline_type& x);

          void
          RespiratoryDriverAmplitudeBaseline (const RespiratoryDriverAmplitudeBaseline_optional& x);

          void
          RespiratoryDriverAmplitudeBaseline (::std::unique_ptr< RespiratoryDriverAmplitudeBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData TotalLungCapacity_type;

          typedef ::xsd::cxx::tree::optional< TotalLungCapacity_type > TotalLungCapacity_optional;

          typedef ::xsd::cxx::tree::traits< TotalLungCapacity_type, char > TotalLungCapacity_traits;

          const TotalLungCapacity_optional&
          TotalLungCapacity () const;

          TotalLungCapacity_optional&
          TotalLungCapacity ();

          void
          TotalLungCapacity (const TotalLungCapacity_type& x);

          void
          TotalLungCapacity (const TotalLungCapacity_optional& x);

          void
          TotalLungCapacity (::std::unique_ptr< TotalLungCapacity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimeData TotalVentilationBaseline_type;

          typedef ::xsd::cxx::tree::optional< TotalVentilationBaseline_type > TotalVentilationBaseline_optional;

          typedef ::xsd::cxx::tree::traits< TotalVentilationBaseline_type, char > TotalVentilationBaseline_traits;

          const TotalVentilationBaseline_optional&
          TotalVentilationBaseline () const;

          TotalVentilationBaseline_optional&
          TotalVentilationBaseline ();

          void
          TotalVentilationBaseline (const TotalVentilationBaseline_type& x);

          void
          TotalVentilationBaseline (const TotalVentilationBaseline_optional& x);

          void
          TotalVentilationBaseline (::std::unique_ptr< TotalVentilationBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumeData VitalCapacity_type;

          typedef ::xsd::cxx::tree::optional< VitalCapacity_type > VitalCapacity_optional;

          typedef ::xsd::cxx::tree::traits< VitalCapacity_type, char > VitalCapacity_traits;

          const VitalCapacity_optional&
          VitalCapacity () const;

          VitalCapacity_optional&
          VitalCapacity ();

          void
          VitalCapacity (const VitalCapacity_type& x);

          void
          VitalCapacity (const VitalCapacity_optional& x);

          void
          VitalCapacity (::std::unique_ptr< VitalCapacity_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ActivePatientEventData ActiveEvent_type;

          typedef ::xsd::cxx::tree::sequence< ActiveEvent_type > ActiveEvent_sequence;

          typedef ActiveEvent_sequence::iterator ActiveEvent_iterator;

          typedef ActiveEvent_sequence::const_iterator ActiveEvent_const_iterator;

          typedef ::xsd::cxx::tree::traits< ActiveEvent_type, char > ActiveEvent_traits;

          const ActiveEvent_sequence&
          ActiveEvent () const;

          ActiveEvent_sequence&
          ActiveEvent ();

          void
          ActiveEvent (const ActiveEvent_sequence& s);



          PatientData ();

          PatientData (const Name_type&);

          PatientData (::std::unique_ptr< Name_type >);

          PatientData (const ::xercesc::DOMElement& e,
                       ::xml_schema::flags f = 0,
                       ::xml_schema::container* c = 0);

          PatientData (const PatientData& x,
                       ::xml_schema::flags f = 0,
                       ::xml_schema::container* c = 0);

          virtual PatientData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          PatientData&
          operator= (const PatientData& x);


          virtual 
          ~PatientData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          Annotation_optional Annotation_;
          ::xsd::cxx::tree::one< Name_type > Name_;
          Sex_optional Sex_;
          Age_optional Age_;
          Weight_optional Weight_;
          Height_optional Height_;
          BodyDensity_optional BodyDensity_;
          BodyFatFraction_optional BodyFatFraction_;
          LeanBodyMass_optional LeanBodyMass_;
          MaxWorkRate_optional MaxWorkRate_;
          MuscleMass_optional MuscleMass_;
          BloodTypeABO_optional BloodTypeABO_;
          BloodTypeRh_optional BloodTypeRh_;
          AlveoliSurfaceArea_optional AlveoliSurfaceArea_;
          Hyperhidrosis_optional Hyperhidrosis_;
          RightLungRatio_optional RightLungRatio_;
          SkinSurfaceArea_optional SkinSurfaceArea_;
          SleepAmount_optional SleepAmount_;
          PainSusceptibility_optional PainSusceptibility_;
          BasalMetabolicRate_optional BasalMetabolicRate_;
          BloodVolumeBaseline_optional BloodVolumeBaseline_;
          DiastolicArterialPressureBaseline_optional DiastolicArterialPressureBaseline_;
          HeartRateBaseline_optional HeartRateBaseline_;
          MeanArterialPressureBaseline_optional MeanArterialPressureBaseline_;
          RespirationRateBaseline_optional RespirationRateBaseline_;
          SystolicArterialPressureBaseline_optional SystolicArterialPressureBaseline_;
          TidalVolumeBaseline_optional TidalVolumeBaseline_;
          HeartRateMaximum_optional HeartRateMaximum_;
          HeartRateMinimum_optional HeartRateMinimum_;
          ExpiratoryReserveVolume_optional ExpiratoryReserveVolume_;
          FunctionalResidualCapacity_optional FunctionalResidualCapacity_;
          InspiratoryCapacity_optional InspiratoryCapacity_;
          InspiratoryReserveVolume_optional InspiratoryReserveVolume_;
          ResidualVolume_optional ResidualVolume_;
          RespiratoryDriverAmplitudeBaseline_optional RespiratoryDriverAmplitudeBaseline_;
          TotalLungCapacity_optional TotalLungCapacity_;
          TotalVentilationBaseline_optional TotalVentilationBaseline_;
          VitalCapacity_optional VitalCapacity_;
          ActiveEvent_sequence ActiveEvent_;

          //@endcond
        };

        class BIOGEARS_CDM_API NormalDistributionRangeData: public ::xml_schema::type
        {
          public:

          typedef ::xml_schema::double_ mean_type;

          typedef ::xsd::cxx::tree::traits< mean_type, char, ::xsd::cxx::tree::schema_type::double_ > mean_traits;

          const mean_type&
          mean () const;

          mean_type&
          mean ();

          void
          mean (const mean_type& x);

          static mean_type
          mean_default_value ();



          typedef ::xml_schema::double_ diviation_type;

          typedef ::xsd::cxx::tree::traits< diviation_type, char, ::xsd::cxx::tree::schema_type::double_ > diviation_traits;

          const diviation_type&
          diviation () const;

          diviation_type&
          diviation ();

          void
          diviation (const diviation_type& x);

          static diviation_type
          diviation_default_value ();



          typedef ::xml_schema::string unit_type;

          typedef ::xsd::cxx::tree::traits< unit_type, char > unit_traits;

          const unit_type&
          unit () const;

          unit_type&
          unit ();

          void
          unit (const unit_type& x);

          void
          unit (::std::unique_ptr< unit_type > p);

          static const unit_type&
          unit_default_value ();



          typedef ::xml_schema::string group_type;

          typedef ::xsd::cxx::tree::traits< group_type, char > group_traits;

          const group_type&
          group () const;

          group_type&
          group ();

          void
          group (const group_type& x);

          void
          group (::std::unique_ptr< group_type > p);

          static const group_type&
          group_default_value ();



          NormalDistributionRangeData ();

          NormalDistributionRangeData (const ::xercesc::DOMElement& e,
                                       ::xml_schema::flags f = 0,
                                       ::xml_schema::container* c = 0);

          NormalDistributionRangeData (const NormalDistributionRangeData& x,
                                       ::xml_schema::flags f = 0,
                                       ::xml_schema::container* c = 0);

          virtual NormalDistributionRangeData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          NormalDistributionRangeData&
          operator= (const NormalDistributionRangeData& x);


          virtual 
          ~NormalDistributionRangeData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          ::xsd::cxx::tree::one< mean_type > mean_;
          ::xsd::cxx::tree::one< diviation_type > diviation_;
          ::xsd::cxx::tree::one< unit_type > unit_;
          static const unit_type unit_default_value_;
          ::xsd::cxx::tree::one< group_type > group_;
          static const group_type group_default_value_;

          //@endcond
        };

        class BIOGEARS_CDM_API DiscreteDistributionRangeData: public ::xml_schema::type
        {
          public:

          typedef ::xml_schema::int_ weight_type;

          typedef ::xsd::cxx::tree::sequence< weight_type > weight_sequence;

          typedef weight_sequence::iterator weight_iterator;

          typedef weight_sequence::const_iterator weight_const_iterator;

          typedef ::xsd::cxx::tree::traits< weight_type, char > weight_traits;

          const weight_sequence&
          weight () const;

          weight_sequence&
          weight ();

          void
          weight (const weight_sequence& s);

          static weight_type
          weight_default_value ();



          typedef ::xml_schema::string group_type;

          typedef ::xsd::cxx::tree::traits< group_type, char > group_traits;

          const group_type&
          group () const;

          group_type&
          group ();

          void
          group (const group_type& x);

          void
          group (::std::unique_ptr< group_type > p);

          static const group_type&
          group_default_value ();



          DiscreteDistributionRangeData ();

          DiscreteDistributionRangeData (const ::xercesc::DOMElement& e,
                                         ::xml_schema::flags f = 0,
                                         ::xml_schema::container* c = 0);

          DiscreteDistributionRangeData (const DiscreteDistributionRangeData& x,
                                         ::xml_schema::flags f = 0,
                                         ::xml_schema::container* c = 0);

          virtual DiscreteDistributionRangeData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          DiscreteDistributionRangeData&
          operator= (const DiscreteDistributionRangeData& x);


          virtual 
          ~DiscreteDistributionRangeData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          weight_sequence weight_;
          ::xsd::cxx::tree::one< group_type > group_;
          static const group_type group_default_value_;

          //@endcond
        };

        class BIOGEARS_CDM_API BernoulliDistributionData: public ::xml_schema::type
        {
          public:

          typedef ::xml_schema::double_ weight_type;

          typedef ::xsd::cxx::tree::traits< weight_type, char, ::xsd::cxx::tree::schema_type::double_ > weight_traits;

          const weight_type&
          weight () const;

          weight_type&
          weight ();

          void
          weight (const weight_type& x);

          static weight_type
          weight_default_value ();



          typedef ::xml_schema::string group_type;

          typedef ::xsd::cxx::tree::traits< group_type, char > group_traits;

          const group_type&
          group () const;

          group_type&
          group ();

          void
          group (const group_type& x);

          void
          group (::std::unique_ptr< group_type > p);

          static const group_type&
          group_default_value ();



          BernoulliDistributionData ();

          BernoulliDistributionData (const weight_type&);

          BernoulliDistributionData (const ::xercesc::DOMElement& e,
                                     ::xml_schema::flags f = 0,
                                     ::xml_schema::container* c = 0);

          BernoulliDistributionData (const BernoulliDistributionData& x,
                                     ::xml_schema::flags f = 0,
                                     ::xml_schema::container* c = 0);

          virtual BernoulliDistributionData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          BernoulliDistributionData&
          operator= (const BernoulliDistributionData& x);


          virtual 
          ~BernoulliDistributionData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          ::xsd::cxx::tree::one< weight_type > weight_;
          ::xsd::cxx::tree::one< group_type > group_;
          static const group_type group_default_value_;

          //@endcond
        };

        class BIOGEARS_CDM_API PopulationData: public ::xml_schema::type
        {
          public:

          typedef ::xml_schema::double_ Heterogametic_SexDistribution_type;

          typedef ::xsd::cxx::tree::traits< Heterogametic_SexDistribution_type, char, ::xsd::cxx::tree::schema_type::double_ > Heterogametic_SexDistribution_traits;

          const Heterogametic_SexDistribution_type&
          Heterogametic_SexDistribution () const;

          Heterogametic_SexDistribution_type&
          Heterogametic_SexDistribution ();

          void
          Heterogametic_SexDistribution (const Heterogametic_SexDistribution_type& x);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData AgeDistribution_type;

          typedef ::xsd::cxx::tree::sequence< AgeDistribution_type > AgeDistribution_sequence;

          typedef AgeDistribution_sequence::iterator AgeDistribution_iterator;

          typedef AgeDistribution_sequence::const_iterator AgeDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< AgeDistribution_type, char > AgeDistribution_traits;

          const AgeDistribution_sequence&
          AgeDistribution () const;

          AgeDistribution_sequence&
          AgeDistribution ();

          void
          AgeDistribution (const AgeDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData WeightDistribution_type;

          typedef ::xsd::cxx::tree::sequence< WeightDistribution_type > WeightDistribution_sequence;

          typedef WeightDistribution_sequence::iterator WeightDistribution_iterator;

          typedef WeightDistribution_sequence::const_iterator WeightDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< WeightDistribution_type, char > WeightDistribution_traits;

          const WeightDistribution_sequence&
          WeightDistribution () const;

          WeightDistribution_sequence&
          WeightDistribution ();

          void
          WeightDistribution (const WeightDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData HeightDistribution_type;

          typedef ::xsd::cxx::tree::sequence< HeightDistribution_type > HeightDistribution_sequence;

          typedef HeightDistribution_sequence::iterator HeightDistribution_iterator;

          typedef HeightDistribution_sequence::const_iterator HeightDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< HeightDistribution_type, char > HeightDistribution_traits;

          const HeightDistribution_sequence&
          HeightDistribution () const;

          HeightDistribution_sequence&
          HeightDistribution ();

          void
          HeightDistribution (const HeightDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData BodyFatFractionDistribution_type;

          typedef ::xsd::cxx::tree::sequence< BodyFatFractionDistribution_type > BodyFatFractionDistribution_sequence;

          typedef BodyFatFractionDistribution_sequence::iterator BodyFatFractionDistribution_iterator;

          typedef BodyFatFractionDistribution_sequence::const_iterator BodyFatFractionDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< BodyFatFractionDistribution_type, char > BodyFatFractionDistribution_traits;

          const BodyFatFractionDistribution_sequence&
          BodyFatFractionDistribution () const;

          BodyFatFractionDistribution_sequence&
          BodyFatFractionDistribution ();

          void
          BodyFatFractionDistribution (const BodyFatFractionDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData MaxWorkRateDistribution_type;

          typedef ::xsd::cxx::tree::sequence< MaxWorkRateDistribution_type > MaxWorkRateDistribution_sequence;

          typedef MaxWorkRateDistribution_sequence::iterator MaxWorkRateDistribution_iterator;

          typedef MaxWorkRateDistribution_sequence::const_iterator MaxWorkRateDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< MaxWorkRateDistribution_type, char > MaxWorkRateDistribution_traits;

          const MaxWorkRateDistribution_sequence&
          MaxWorkRateDistribution () const;

          MaxWorkRateDistribution_sequence&
          MaxWorkRateDistribution ();

          void
          MaxWorkRateDistribution (const MaxWorkRateDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::DiscreteDistributionRangeData BloodTypeABODistribution_type;

          typedef ::xsd::cxx::tree::sequence< BloodTypeABODistribution_type > BloodTypeABODistribution_sequence;

          typedef BloodTypeABODistribution_sequence::iterator BloodTypeABODistribution_iterator;

          typedef BloodTypeABODistribution_sequence::const_iterator BloodTypeABODistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< BloodTypeABODistribution_type, char > BloodTypeABODistribution_traits;

          const BloodTypeABODistribution_sequence&
          BloodTypeABODistribution () const;

          BloodTypeABODistribution_sequence&
          BloodTypeABODistribution ();

          void
          BloodTypeABODistribution (const BloodTypeABODistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::BernoulliDistributionData BloodTypeRhDistribution_type;

          typedef ::xsd::cxx::tree::sequence< BloodTypeRhDistribution_type > BloodTypeRhDistribution_sequence;

          typedef BloodTypeRhDistribution_sequence::iterator BloodTypeRhDistribution_iterator;

          typedef BloodTypeRhDistribution_sequence::const_iterator BloodTypeRhDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< BloodTypeRhDistribution_type, char > BloodTypeRhDistribution_traits;

          const BloodTypeRhDistribution_sequence&
          BloodTypeRhDistribution () const;

          BloodTypeRhDistribution_sequence&
          BloodTypeRhDistribution ();

          void
          BloodTypeRhDistribution (const BloodTypeRhDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData AlveoliSurfaceAreaDistribution_type;

          typedef ::xsd::cxx::tree::sequence< AlveoliSurfaceAreaDistribution_type > AlveoliSurfaceAreaDistribution_sequence;

          typedef AlveoliSurfaceAreaDistribution_sequence::iterator AlveoliSurfaceAreaDistribution_iterator;

          typedef AlveoliSurfaceAreaDistribution_sequence::const_iterator AlveoliSurfaceAreaDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< AlveoliSurfaceAreaDistribution_type, char > AlveoliSurfaceAreaDistribution_traits;

          const AlveoliSurfaceAreaDistribution_sequence&
          AlveoliSurfaceAreaDistribution () const;

          AlveoliSurfaceAreaDistribution_sequence&
          AlveoliSurfaceAreaDistribution ();

          void
          AlveoliSurfaceAreaDistribution (const AlveoliSurfaceAreaDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData HyperhidrosisDistribution_type;

          typedef ::xsd::cxx::tree::sequence< HyperhidrosisDistribution_type > HyperhidrosisDistribution_sequence;

          typedef HyperhidrosisDistribution_sequence::iterator HyperhidrosisDistribution_iterator;

          typedef HyperhidrosisDistribution_sequence::const_iterator HyperhidrosisDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< HyperhidrosisDistribution_type, char > HyperhidrosisDistribution_traits;

          const HyperhidrosisDistribution_sequence&
          HyperhidrosisDistribution () const;

          HyperhidrosisDistribution_sequence&
          HyperhidrosisDistribution ();

          void
          HyperhidrosisDistribution (const HyperhidrosisDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData RightLungRatioDistribution_type;

          typedef ::xsd::cxx::tree::sequence< RightLungRatioDistribution_type > RightLungRatioDistribution_sequence;

          typedef RightLungRatioDistribution_sequence::iterator RightLungRatioDistribution_iterator;

          typedef RightLungRatioDistribution_sequence::const_iterator RightLungRatioDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< RightLungRatioDistribution_type, char > RightLungRatioDistribution_traits;

          const RightLungRatioDistribution_sequence&
          RightLungRatioDistribution () const;

          RightLungRatioDistribution_sequence&
          RightLungRatioDistribution ();

          void
          RightLungRatioDistribution (const RightLungRatioDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData SkinSurfaceAreaDistribution_type;

          typedef ::xsd::cxx::tree::sequence< SkinSurfaceAreaDistribution_type > SkinSurfaceAreaDistribution_sequence;

          typedef SkinSurfaceAreaDistribution_sequence::iterator SkinSurfaceAreaDistribution_iterator;

          typedef SkinSurfaceAreaDistribution_sequence::const_iterator SkinSurfaceAreaDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< SkinSurfaceAreaDistribution_type, char > SkinSurfaceAreaDistribution_traits;

          const SkinSurfaceAreaDistribution_sequence&
          SkinSurfaceAreaDistribution () const;

          SkinSurfaceAreaDistribution_sequence&
          SkinSurfaceAreaDistribution ();

          void
          SkinSurfaceAreaDistribution (const SkinSurfaceAreaDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData SleepAmountDistribution_type;

          typedef ::xsd::cxx::tree::sequence< SleepAmountDistribution_type > SleepAmountDistribution_sequence;

          typedef SleepAmountDistribution_sequence::iterator SleepAmountDistribution_iterator;

          typedef SleepAmountDistribution_sequence::const_iterator SleepAmountDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< SleepAmountDistribution_type, char > SleepAmountDistribution_traits;

          const SleepAmountDistribution_sequence&
          SleepAmountDistribution () const;

          SleepAmountDistribution_sequence&
          SleepAmountDistribution ();

          void
          SleepAmountDistribution (const SleepAmountDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData PainSusceptibilityDistribution_type;

          typedef ::xsd::cxx::tree::sequence< PainSusceptibilityDistribution_type > PainSusceptibilityDistribution_sequence;

          typedef PainSusceptibilityDistribution_sequence::iterator PainSusceptibilityDistribution_iterator;

          typedef PainSusceptibilityDistribution_sequence::const_iterator PainSusceptibilityDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< PainSusceptibilityDistribution_type, char > PainSusceptibilityDistribution_traits;

          const PainSusceptibilityDistribution_sequence&
          PainSusceptibilityDistribution () const;

          PainSusceptibilityDistribution_sequence&
          PainSusceptibilityDistribution ();

          void
          PainSusceptibilityDistribution (const PainSusceptibilityDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData BasalMetabolicRateDistribution_type;

          typedef ::xsd::cxx::tree::sequence< BasalMetabolicRateDistribution_type > BasalMetabolicRateDistribution_sequence;

          typedef BasalMetabolicRateDistribution_sequence::iterator BasalMetabolicRateDistribution_iterator;

          typedef BasalMetabolicRateDistribution_sequence::const_iterator BasalMetabolicRateDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< BasalMetabolicRateDistribution_type, char > BasalMetabolicRateDistribution_traits;

          const BasalMetabolicRateDistribution_sequence&
          BasalMetabolicRateDistribution () const;

          BasalMetabolicRateDistribution_sequence&
          BasalMetabolicRateDistribution ();

          void
          BasalMetabolicRateDistribution (const BasalMetabolicRateDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData BloodVolumeBaselineDistribution_type;

          typedef ::xsd::cxx::tree::sequence< BloodVolumeBaselineDistribution_type > BloodVolumeBaselineDistribution_sequence;

          typedef BloodVolumeBaselineDistribution_sequence::iterator BloodVolumeBaselineDistribution_iterator;

          typedef BloodVolumeBaselineDistribution_sequence::const_iterator BloodVolumeBaselineDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< BloodVolumeBaselineDistribution_type, char > BloodVolumeBaselineDistribution_traits;

          const BloodVolumeBaselineDistribution_sequence&
          BloodVolumeBaselineDistribution () const;

          BloodVolumeBaselineDistribution_sequence&
          BloodVolumeBaselineDistribution ();

          void
          BloodVolumeBaselineDistribution (const BloodVolumeBaselineDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData DiastolicArterialPressureBaselineDistribution_type;

          typedef ::xsd::cxx::tree::sequence< DiastolicArterialPressureBaselineDistribution_type > DiastolicArterialPressureBaselineDistribution_sequence;

          typedef DiastolicArterialPressureBaselineDistribution_sequence::iterator DiastolicArterialPressureBaselineDistribution_iterator;

          typedef DiastolicArterialPressureBaselineDistribution_sequence::const_iterator DiastolicArterialPressureBaselineDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< DiastolicArterialPressureBaselineDistribution_type, char > DiastolicArterialPressureBaselineDistribution_traits;

          const DiastolicArterialPressureBaselineDistribution_sequence&
          DiastolicArterialPressureBaselineDistribution () const;

          DiastolicArterialPressureBaselineDistribution_sequence&
          DiastolicArterialPressureBaselineDistribution ();

          void
          DiastolicArterialPressureBaselineDistribution (const DiastolicArterialPressureBaselineDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData HeartRateBaselineDistribution_type;

          typedef ::xsd::cxx::tree::sequence< HeartRateBaselineDistribution_type > HeartRateBaselineDistribution_sequence;

          typedef HeartRateBaselineDistribution_sequence::iterator HeartRateBaselineDistribution_iterator;

          typedef HeartRateBaselineDistribution_sequence::const_iterator HeartRateBaselineDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< HeartRateBaselineDistribution_type, char > HeartRateBaselineDistribution_traits;

          const HeartRateBaselineDistribution_sequence&
          HeartRateBaselineDistribution () const;

          HeartRateBaselineDistribution_sequence&
          HeartRateBaselineDistribution ();

          void
          HeartRateBaselineDistribution (const HeartRateBaselineDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData RespirationRateBaselineDistribution_type;

          typedef ::xsd::cxx::tree::sequence< RespirationRateBaselineDistribution_type > RespirationRateBaselineDistribution_sequence;

          typedef RespirationRateBaselineDistribution_sequence::iterator RespirationRateBaselineDistribution_iterator;

          typedef RespirationRateBaselineDistribution_sequence::const_iterator RespirationRateBaselineDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< RespirationRateBaselineDistribution_type, char > RespirationRateBaselineDistribution_traits;

          const RespirationRateBaselineDistribution_sequence&
          RespirationRateBaselineDistribution () const;

          RespirationRateBaselineDistribution_sequence&
          RespirationRateBaselineDistribution ();

          void
          RespirationRateBaselineDistribution (const RespirationRateBaselineDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData SystolicArterialPressureBaselineDistribution_type;

          typedef ::xsd::cxx::tree::sequence< SystolicArterialPressureBaselineDistribution_type > SystolicArterialPressureBaselineDistribution_sequence;

          typedef SystolicArterialPressureBaselineDistribution_sequence::iterator SystolicArterialPressureBaselineDistribution_iterator;

          typedef SystolicArterialPressureBaselineDistribution_sequence::const_iterator SystolicArterialPressureBaselineDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< SystolicArterialPressureBaselineDistribution_type, char > SystolicArterialPressureBaselineDistribution_traits;

          const SystolicArterialPressureBaselineDistribution_sequence&
          SystolicArterialPressureBaselineDistribution () const;

          SystolicArterialPressureBaselineDistribution_sequence&
          SystolicArterialPressureBaselineDistribution ();

          void
          SystolicArterialPressureBaselineDistribution (const SystolicArterialPressureBaselineDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData HeartRateMaximumDistribution_type;

          typedef ::xsd::cxx::tree::sequence< HeartRateMaximumDistribution_type > HeartRateMaximumDistribution_sequence;

          typedef HeartRateMaximumDistribution_sequence::iterator HeartRateMaximumDistribution_iterator;

          typedef HeartRateMaximumDistribution_sequence::const_iterator HeartRateMaximumDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< HeartRateMaximumDistribution_type, char > HeartRateMaximumDistribution_traits;

          const HeartRateMaximumDistribution_sequence&
          HeartRateMaximumDistribution () const;

          HeartRateMaximumDistribution_sequence&
          HeartRateMaximumDistribution ();

          void
          HeartRateMaximumDistribution (const HeartRateMaximumDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData HeartRateMinimumDistribution_type;

          typedef ::xsd::cxx::tree::sequence< HeartRateMinimumDistribution_type > HeartRateMinimumDistribution_sequence;

          typedef HeartRateMinimumDistribution_sequence::iterator HeartRateMinimumDistribution_iterator;

          typedef HeartRateMinimumDistribution_sequence::const_iterator HeartRateMinimumDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< HeartRateMinimumDistribution_type, char > HeartRateMinimumDistribution_traits;

          const HeartRateMinimumDistribution_sequence&
          HeartRateMinimumDistribution () const;

          HeartRateMinimumDistribution_sequence&
          HeartRateMinimumDistribution ();

          void
          HeartRateMinimumDistribution (const HeartRateMinimumDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData FunctionalResidualCapacityDistribution_type;

          typedef ::xsd::cxx::tree::sequence< FunctionalResidualCapacityDistribution_type > FunctionalResidualCapacityDistribution_sequence;

          typedef FunctionalResidualCapacityDistribution_sequence::iterator FunctionalResidualCapacityDistribution_iterator;

          typedef FunctionalResidualCapacityDistribution_sequence::const_iterator FunctionalResidualCapacityDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< FunctionalResidualCapacityDistribution_type, char > FunctionalResidualCapacityDistribution_traits;

          const FunctionalResidualCapacityDistribution_sequence&
          FunctionalResidualCapacityDistribution () const;

          FunctionalResidualCapacityDistribution_sequence&
          FunctionalResidualCapacityDistribution ();

          void
          FunctionalResidualCapacityDistribution (const FunctionalResidualCapacityDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData ResidualVolumeDistribution_type;

          typedef ::xsd::cxx::tree::sequence< ResidualVolumeDistribution_type > ResidualVolumeDistribution_sequence;

          typedef ResidualVolumeDistribution_sequence::iterator ResidualVolumeDistribution_iterator;

          typedef ResidualVolumeDistribution_sequence::const_iterator ResidualVolumeDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< ResidualVolumeDistribution_type, char > ResidualVolumeDistribution_traits;

          const ResidualVolumeDistribution_sequence&
          ResidualVolumeDistribution () const;

          ResidualVolumeDistribution_sequence&
          ResidualVolumeDistribution ();

          void
          ResidualVolumeDistribution (const ResidualVolumeDistribution_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::NormalDistributionRangeData TotalLungCapacityDistribution_type;

          typedef ::xsd::cxx::tree::sequence< TotalLungCapacityDistribution_type > TotalLungCapacityDistribution_sequence;

          typedef TotalLungCapacityDistribution_sequence::iterator TotalLungCapacityDistribution_iterator;

          typedef TotalLungCapacityDistribution_sequence::const_iterator TotalLungCapacityDistribution_const_iterator;

          typedef ::xsd::cxx::tree::traits< TotalLungCapacityDistribution_type, char > TotalLungCapacityDistribution_traits;

          const TotalLungCapacityDistribution_sequence&
          TotalLungCapacityDistribution () const;

          TotalLungCapacityDistribution_sequence&
          TotalLungCapacityDistribution ();

          void
          TotalLungCapacityDistribution (const TotalLungCapacityDistribution_sequence& s);



          PopulationData ();

          PopulationData (const Heterogametic_SexDistribution_type&);

          PopulationData (const ::xercesc::DOMElement& e,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);

          PopulationData (const PopulationData& x,
                          ::xml_schema::flags f = 0,
                          ::xml_schema::container* c = 0);

          virtual PopulationData*
          _clone (::xml_schema::flags f = 0,
                  ::xml_schema::container* c = 0) const;

          PopulationData&
          operator= (const PopulationData& x);


          virtual 
          ~PopulationData ();

          // Implementation.
          //

          //@cond

          protected:
          void
          parse (::xsd::cxx::xml::dom::parser< char >&,
                 ::xml_schema::flags);

          protected:
          ::xsd::cxx::tree::one< Heterogametic_SexDistribution_type > Heterogametic_SexDistribution_;
          AgeDistribution_sequence AgeDistribution_;
          WeightDistribution_sequence WeightDistribution_;
          HeightDistribution_sequence HeightDistribution_;
          BodyFatFractionDistribution_sequence BodyFatFractionDistribution_;
          MaxWorkRateDistribution_sequence MaxWorkRateDistribution_;
          BloodTypeABODistribution_sequence BloodTypeABODistribution_;
          BloodTypeRhDistribution_sequence BloodTypeRhDistribution_;
          AlveoliSurfaceAreaDistribution_sequence AlveoliSurfaceAreaDistribution_;
          HyperhidrosisDistribution_sequence HyperhidrosisDistribution_;
          RightLungRatioDistribution_sequence RightLungRatioDistribution_;
          SkinSurfaceAreaDistribution_sequence SkinSurfaceAreaDistribution_;
          SleepAmountDistribution_sequence SleepAmountDistribution_;
          PainSusceptibilityDistribution_sequence PainSusceptibilityDistribution_;
          BasalMetabolicRateDistribution_sequence BasalMetabolicRateDistribution_;
          BloodVolumeBaselineDistribution_sequence BloodVolumeBaselineDistribution_;
          DiastolicArterialPressureBaselineDistribution_sequence DiastolicArterialPressureBaselineDistribution_;
          HeartRateBaselineDistribution_sequence HeartRateBaselineDistribution_;
          RespirationRateBaselineDistribution_sequence RespirationRateBaselineDistribution_;
          SystolicArterialPressureBaselineDistribution_sequence SystolicArterialPressureBaselineDistribution_;
          HeartRateMaximumDistribution_sequence HeartRateMaximumDistribution_;
          HeartRateMinimumDistribution_sequence HeartRateMinimumDistribution_;
          FunctionalResidualCapacityDistribution_sequence FunctionalResidualCapacityDistribution_;
          ResidualVolumeDistribution_sequence ResidualVolumeDistribution_;
          TotalLungCapacityDistribution_sequence TotalLungCapacityDistribution_;

          //@endcond
        };
      }
    }
  }
}

#include <iosfwd>

namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {
        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, enumSex::value);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const enumSex&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, enumBloodType::value);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const enumBloodType&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, enumPatientEvent::value);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const enumPatientEvent&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const ActivePatientEventData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const PatientData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const NormalDistributionRangeData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const DiscreteDistributionRangeData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const BernoulliDistributionData&);

        BIOGEARS_CDM_API
        ::std::ostream&
        operator<< (::std::ostream&, const PopulationData&);
      }
    }
  }
}

#include <iosfwd>

#include <xercesc/sax/InputSource.hpp>
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>

namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (const ::std::string& uri,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (const ::std::string& uri,
                 ::xml_schema::error_handler& eh,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (const ::std::string& uri,
                 ::xercesc::DOMErrorHandler& eh,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (::std::istream& is,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (::std::istream& is,
                 ::xml_schema::error_handler& eh,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (::std::istream& is,
                 ::xercesc::DOMErrorHandler& eh,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (::std::istream& is,
                 const ::std::string& id,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (::std::istream& is,
                 const ::std::string& id,
                 ::xml_schema::error_handler& eh,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (::std::istream& is,
                 const ::std::string& id,
                 ::xercesc::DOMErrorHandler& eh,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (::xercesc::InputSource& is,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (::xercesc::InputSource& is,
                 ::xml_schema::error_handler& eh,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (::xercesc::InputSource& is,
                 ::xercesc::DOMErrorHandler& eh,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (const ::xercesc::DOMDocument& d,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PatientData >
        Patient (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
                 ::xml_schema::flags f = 0,
                 const ::xml_schema::properties& p = ::xml_schema::properties ());



        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (const ::std::string& uri,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (const ::std::string& uri,
                           ::xml_schema::error_handler& eh,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (const ::std::string& uri,
                           ::xercesc::DOMErrorHandler& eh,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (::std::istream& is,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (::std::istream& is,
                           ::xml_schema::error_handler& eh,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (::std::istream& is,
                           ::xercesc::DOMErrorHandler& eh,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (::std::istream& is,
                           const ::std::string& id,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (::std::istream& is,
                           const ::std::string& id,
                           ::xml_schema::error_handler& eh,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (::std::istream& is,
                           const ::std::string& id,
                           ::xercesc::DOMErrorHandler& eh,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (::xercesc::InputSource& is,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (::xercesc::InputSource& is,
                           ::xml_schema::error_handler& eh,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (::xercesc::InputSource& is,
                           ::xercesc::DOMErrorHandler& eh,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (const ::xercesc::DOMDocument& d,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

        BIOGEARS_CDM_API
        ::std::unique_ptr< ::mil::tatrc::physiology::datamodel::PopulationData >
        PopulationProfile (::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument > d,
                           ::xml_schema::flags f = 0,
                           const ::xml_schema::properties& p = ::xml_schema::properties ());

      }
    }
  }
}

#include <iosfwd>

#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
#include <xercesc/framework/XMLFormatter.hpp>

#include <xsd/cxx/xml/dom/auto-ptr.hxx>

namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {
        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const enumSex&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMAttr&, const enumSex&);

        BIOGEARS_CDM_API
        void
        operator<< (::xml_schema::list_stream&,
                    const enumSex&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const enumBloodType&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMAttr&, const enumBloodType&);

        BIOGEARS_CDM_API
        void
        operator<< (::xml_schema::list_stream&,
                    const enumBloodType&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const enumPatientEvent&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMAttr&, const enumPatientEvent&);

        BIOGEARS_CDM_API
        void
        operator<< (::xml_schema::list_stream&,
                    const enumPatientEvent&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const ActivePatientEventData&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const PatientData&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const NormalDistributionRangeData&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const DiscreteDistributionRangeData&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const BernoulliDistributionData&);

        BIOGEARS_CDM_API
        void
        operator<< (::xercesc::DOMElement&, const PopulationData&);


        BIOGEARS_CDM_API
        void
        Patient (::std::ostream& os,
                 const ::mil::tatrc::physiology::datamodel::PatientData& x, 
                 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                 const ::std::string& e = "UTF-8",
                 ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Patient (::std::ostream& os,
                 const ::mil::tatrc::physiology::datamodel::PatientData& x, 
                 ::xml_schema::error_handler& eh,
                 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                 const ::std::string& e = "UTF-8",
                 ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Patient (::std::ostream& os,
                 const ::mil::tatrc::physiology::datamodel::PatientData& x, 
                 ::xercesc::DOMErrorHandler& eh,
                 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                 const ::std::string& e = "UTF-8",
                 ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Patient (::xercesc::XMLFormatTarget& ft,
                 const ::mil::tatrc::physiology::datamodel::PatientData& x, 
                 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                 const ::std::string& e = "UTF-8",
                 ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Patient (::xercesc::XMLFormatTarget& ft,
                 const ::mil::tatrc::physiology::datamodel::PatientData& x, 
                 ::xml_schema::error_handler& eh,
                 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                 const ::std::string& e = "UTF-8",
                 ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Patient (::xercesc::XMLFormatTarget& ft,
                 const ::mil::tatrc::physiology::datamodel::PatientData& x, 
                 ::xercesc::DOMErrorHandler& eh,
                 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                 const ::std::string& e = "UTF-8",
                 ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        Patient (::xercesc::DOMDocument& d,
                 const ::mil::tatrc::physiology::datamodel::PatientData& x,
                 ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
        Patient (const ::mil::tatrc::physiology::datamodel::PatientData& x, 
                 const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                 ::xml_schema::flags f = 0);



        BIOGEARS_CDM_API
        void
        PopulationProfile (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::PopulationData& x, 
                           const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                           const ::std::string& e = "UTF-8",
                           ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PopulationProfile (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::PopulationData& x, 
                           ::xml_schema::error_handler& eh,
                           const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                           const ::std::string& e = "UTF-8",
                           ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PopulationProfile (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::PopulationData& x, 
                           ::xercesc::DOMErrorHandler& eh,
                           const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                           const ::std::string& e = "UTF-8",
                           ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PopulationProfile (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::PopulationData& x, 
                           const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                           const ::std::string& e = "UTF-8",
                           ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PopulationProfile (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::PopulationData& x, 
                           ::xml_schema::error_handler& eh,
                           const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                           const ::std::string& e = "UTF-8",
                           ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PopulationProfile (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::PopulationData& x, 
                           ::xercesc::DOMErrorHandler& eh,
                           const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                           const ::std::string& e = "UTF-8",
                           ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        void
        PopulationProfile (::xercesc::DOMDocument& d,
                           const ::mil::tatrc::physiology::datamodel::PopulationData& x,
                           ::xml_schema::flags f = 0);

        BIOGEARS_CDM_API
        ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
        PopulationProfile (const ::mil::tatrc::physiology::datamodel::PopulationData& x, 
                           const ::xml_schema::namespace_infomap& m = ::xml_schema::namespace_infomap (),
                           ::xml_schema::flags f = 0);

      }
    }
  }
}

#include <xsd/cxx/post.hxx>

// Begin epilogue.
//
//
// End epilogue.

#endif // D__BIOGEARS_CORE_SHARE_XSD__CDM_PATIENT_HXX