Substance.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_SUBSTANCE_HXX
#define D__BIOGEARS_CORE_SHARE_XSD__CDM_SUBSTANCE_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 enumSubstanceState;
        class enumSubstanceIonicState;
        class enumSubstanceBindingProtein;
        class enumCharge;
        class enumSubstanceClass;
        class SubstanceAerosolizationData;
        class SubstancePharmacokineticsData;
        class SubstancePhysicochemicalData;
        class SubstanceTissuePharmacokineticsData;
        class SubstancePharmacodynamicsData;
        class SubstanceClearanceData;
        class SubstanceData;
        class SubstanceCompoundData;
        class SubstanceFractionData;
        class SubstanceConcentrationData;
        class PharmacodynamicModifierData;
        class Systemic;
        class RenalDynamics;
        class CellRegulation;
        class Regulation;
      }
    }
  }
}


#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"

#include "physiology.hxx"

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

          enum value
          {
            Solid,
            Liquid,
            Gas,
            Molecular
          };

          enumSubstanceState ();

          enumSubstanceState (value v);

          enumSubstanceState (const char* v);

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

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

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

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

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

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

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

          enumSubstanceState&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumSubstanceState_convert () const;

          public:
          static const char* const _xsd_enumSubstanceState_literals_[4];
          static const value _xsd_enumSubstanceState_indexes_[4];

          //@endcond
        };

        class BIOGEARS_CDM_API enumSubstanceIonicState: public ::xml_schema::string
        {
          public:

          enum value
          {
            WeakBase,
            Base,
            Acid,
            Neutral,
            Zwitterion
          };

          enumSubstanceIonicState ();

          enumSubstanceIonicState (value v);

          enumSubstanceIonicState (const char* v);

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

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

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

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

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

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

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

          enumSubstanceIonicState&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumSubstanceIonicState_convert () const;

          public:
          static const char* const _xsd_enumSubstanceIonicState_literals_[5];
          static const value _xsd_enumSubstanceIonicState_indexes_[5];

          //@endcond
        };

        class BIOGEARS_CDM_API enumSubstanceBindingProtein: public ::xml_schema::string
        {
          public:

          enum value
          {
            Albumin,
            Lipoprotein,
            AAG
          };

          enumSubstanceBindingProtein ();

          enumSubstanceBindingProtein (value v);

          enumSubstanceBindingProtein (const char* v);

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

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

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

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

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

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

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

          enumSubstanceBindingProtein&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumSubstanceBindingProtein_convert () const;

          public:
          static const char* const _xsd_enumSubstanceBindingProtein_literals_[3];
          static const value _xsd_enumSubstanceBindingProtein_indexes_[3];

          //@endcond
        };

        class BIOGEARS_CDM_API enumCharge: public ::xml_schema::string
        {
          public:

          enum value
          {
            Positive,
            Negative,
            Neutral
          };

          enumCharge ();

          enumCharge (value v);

          enumCharge (const char* v);

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

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

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

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

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

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

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

          enumCharge&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumCharge_convert () const;

          public:
          static const char* const _xsd_enumCharge_literals_[3];
          static const value _xsd_enumCharge_indexes_[3];

          //@endcond
        };

        class BIOGEARS_CDM_API enumSubstanceClass: public ::xml_schema::string
        {
          public:

          enum value
          {
            Anesthetic,
            Antibiotic,
            WholeBlood,
            Ion,
            Opioid,
            ReversalAgent,
            Sedative
          };

          enumSubstanceClass ();

          enumSubstanceClass (value v);

          enumSubstanceClass (const char* v);

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

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

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

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

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

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

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

          enumSubstanceClass&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumSubstanceClass_convert () const;

          public:
          static const char* const _xsd_enumSubstanceClass_literals_[7];
          static const value _xsd_enumSubstanceClass_indexes_[7];

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::traits< BronchioleModifier_type, char > BronchioleModifier_traits;

          const BronchioleModifier_type&
          BronchioleModifier () const;

          BronchioleModifier_type&
          BronchioleModifier ();

          void
          BronchioleModifier (const BronchioleModifier_type& x);

          void
          BronchioleModifier (::std::unique_ptr< BronchioleModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::Scalar0To1Data InflammationCoefficient_type;

          typedef ::xsd::cxx::tree::traits< InflammationCoefficient_type, char > InflammationCoefficient_traits;

          const InflammationCoefficient_type&
          InflammationCoefficient () const;

          InflammationCoefficient_type&
          InflammationCoefficient ();

          void
          InflammationCoefficient (const InflammationCoefficient_type& x);

          void
          InflammationCoefficient (::std::unique_ptr< InflammationCoefficient_type > p);



          typedef ::mil::tatrc::physiology::datamodel::HistogramFractionVsLengthData ParticulateSizeDistribution_type;

          typedef ::xsd::cxx::tree::traits< ParticulateSizeDistribution_type, char > ParticulateSizeDistribution_traits;

          const ParticulateSizeDistribution_type&
          ParticulateSizeDistribution () const;

          ParticulateSizeDistribution_type&
          ParticulateSizeDistribution ();

          void
          ParticulateSizeDistribution (const ParticulateSizeDistribution_type& x);

          void
          ParticulateSizeDistribution (::std::unique_ptr< ParticulateSizeDistribution_type > p);



          SubstanceAerosolizationData ();

          SubstanceAerosolizationData (const BronchioleModifier_type&,
                                       const InflammationCoefficient_type&,
                                       const ParticulateSizeDistribution_type&);

          SubstanceAerosolizationData (::std::unique_ptr< BronchioleModifier_type >,
                                       ::std::unique_ptr< InflammationCoefficient_type >,
                                       ::std::unique_ptr< ParticulateSizeDistribution_type >);

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

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

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

          SubstanceAerosolizationData&
          operator= (const SubstanceAerosolizationData& x);


          virtual 
          ~SubstanceAerosolizationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< BronchioleModifier_type > BronchioleModifier_;
          ::xsd::cxx::tree::one< InflammationCoefficient_type > InflammationCoefficient_;
          ::xsd::cxx::tree::one< ParticulateSizeDistribution_type > ParticulateSizeDistribution_;

          //@endcond
        };

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

          typedef ::mil::tatrc::physiology::datamodel::SubstancePhysicochemicalData Physicochemicals_type;

          typedef ::xsd::cxx::tree::optional< Physicochemicals_type > Physicochemicals_optional;

          typedef ::xsd::cxx::tree::traits< Physicochemicals_type, char > Physicochemicals_traits;

          const Physicochemicals_optional&
          Physicochemicals () const;

          Physicochemicals_optional&
          Physicochemicals ();

          void
          Physicochemicals (const Physicochemicals_type& x);

          void
          Physicochemicals (const Physicochemicals_optional& x);

          void
          Physicochemicals (::std::unique_ptr< Physicochemicals_type > p);



          typedef ::mil::tatrc::physiology::datamodel::SubstanceTissuePharmacokineticsData TissueKinetics_type;

          typedef ::xsd::cxx::tree::sequence< TissueKinetics_type > TissueKinetics_sequence;

          typedef TissueKinetics_sequence::iterator TissueKinetics_iterator;

          typedef TissueKinetics_sequence::const_iterator TissueKinetics_const_iterator;

          typedef ::xsd::cxx::tree::traits< TissueKinetics_type, char > TissueKinetics_traits;

          const TissueKinetics_sequence&
          TissueKinetics () const;

          TissueKinetics_sequence&
          TissueKinetics ();

          void
          TissueKinetics (const TissueKinetics_sequence& s);



          SubstancePharmacokineticsData ();

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

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

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

          SubstancePharmacokineticsData&
          operator= (const SubstancePharmacokineticsData& x);


          virtual 
          ~SubstancePharmacokineticsData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Physicochemicals_optional Physicochemicals_;
          TissueKinetics_sequence TissueKinetics_;

          //@endcond
        };

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

          typedef ::mil::tatrc::physiology::datamodel::ScalarData AcidDissociationConstant_type;

          typedef ::xsd::cxx::tree::sequence< AcidDissociationConstant_type > AcidDissociationConstant_sequence;

          typedef AcidDissociationConstant_sequence::iterator AcidDissociationConstant_iterator;

          typedef AcidDissociationConstant_sequence::const_iterator AcidDissociationConstant_const_iterator;

          typedef ::xsd::cxx::tree::traits< AcidDissociationConstant_type, char > AcidDissociationConstant_traits;

          const AcidDissociationConstant_sequence&
          AcidDissociationConstant () const;

          AcidDissociationConstant_sequence&
          AcidDissociationConstant ();

          void
          AcidDissociationConstant (const AcidDissociationConstant_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::enumSubstanceBindingProtein BindingProtein_type;

          typedef ::xsd::cxx::tree::traits< BindingProtein_type, char > BindingProtein_traits;

          const BindingProtein_type&
          BindingProtein () const;

          BindingProtein_type&
          BindingProtein ();

          void
          BindingProtein (const BindingProtein_type& x);

          void
          BindingProtein (::std::unique_ptr< BindingProtein_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData BloodPlasmaRatio_type;

          typedef ::xsd::cxx::tree::traits< BloodPlasmaRatio_type, char > BloodPlasmaRatio_traits;

          const BloodPlasmaRatio_type&
          BloodPlasmaRatio () const;

          BloodPlasmaRatio_type&
          BloodPlasmaRatio ();

          void
          BloodPlasmaRatio (const BloodPlasmaRatio_type& x);

          void
          BloodPlasmaRatio (::std::unique_ptr< BloodPlasmaRatio_type > p);



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

          typedef ::xsd::cxx::tree::traits< FractionUnboundInPlasma_type, char > FractionUnboundInPlasma_traits;

          const FractionUnboundInPlasma_type&
          FractionUnboundInPlasma () const;

          FractionUnboundInPlasma_type&
          FractionUnboundInPlasma ();

          void
          FractionUnboundInPlasma (const FractionUnboundInPlasma_type& x);

          void
          FractionUnboundInPlasma (::std::unique_ptr< FractionUnboundInPlasma_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumSubstanceIonicState IonicState_type;

          typedef ::xsd::cxx::tree::traits< IonicState_type, char > IonicState_traits;

          const IonicState_type&
          IonicState () const;

          IonicState_type&
          IonicState ();

          void
          IonicState (const IonicState_type& x);

          void
          IonicState (::std::unique_ptr< IonicState_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData LogP_type;

          typedef ::xsd::cxx::tree::traits< LogP_type, char > LogP_traits;

          const LogP_type&
          LogP () const;

          LogP_type&
          LogP ();

          void
          LogP (const LogP_type& x);

          void
          LogP (::std::unique_ptr< LogP_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData HydrogenBondCount_type;

          typedef ::xsd::cxx::tree::optional< HydrogenBondCount_type > HydrogenBondCount_optional;

          typedef ::xsd::cxx::tree::traits< HydrogenBondCount_type, char > HydrogenBondCount_traits;

          const HydrogenBondCount_optional&
          HydrogenBondCount () const;

          HydrogenBondCount_optional&
          HydrogenBondCount ();

          void
          HydrogenBondCount (const HydrogenBondCount_type& x);

          void
          HydrogenBondCount (const HydrogenBondCount_optional& x);

          void
          HydrogenBondCount (::std::unique_ptr< HydrogenBondCount_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData PolarSurfaceArea_type;

          typedef ::xsd::cxx::tree::optional< PolarSurfaceArea_type > PolarSurfaceArea_optional;

          typedef ::xsd::cxx::tree::traits< PolarSurfaceArea_type, char > PolarSurfaceArea_traits;

          const PolarSurfaceArea_optional&
          PolarSurfaceArea () const;

          PolarSurfaceArea_optional&
          PolarSurfaceArea ();

          void
          PolarSurfaceArea (const PolarSurfaceArea_type& x);

          void
          PolarSurfaceArea (const PolarSurfaceArea_optional& x);

          void
          PolarSurfaceArea (::std::unique_ptr< PolarSurfaceArea_type > p);



          SubstancePhysicochemicalData ();

          SubstancePhysicochemicalData (const BindingProtein_type&,
                                        const BloodPlasmaRatio_type&,
                                        const FractionUnboundInPlasma_type&,
                                        const IonicState_type&,
                                        const LogP_type&);

          SubstancePhysicochemicalData (const BindingProtein_type&,
                                        ::std::unique_ptr< BloodPlasmaRatio_type >,
                                        ::std::unique_ptr< FractionUnboundInPlasma_type >,
                                        const IonicState_type&,
                                        ::std::unique_ptr< LogP_type >);

          SubstancePhysicochemicalData (::std::unique_ptr< BindingProtein_type >,
                                        ::std::unique_ptr< BloodPlasmaRatio_type >,
                                        ::std::unique_ptr< FractionUnboundInPlasma_type >,
                                        ::std::unique_ptr< IonicState_type >,
                                        ::std::unique_ptr< LogP_type >);

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

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

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

          SubstancePhysicochemicalData&
          operator= (const SubstancePhysicochemicalData& x);


          virtual 
          ~SubstancePhysicochemicalData ();

          // Implementation.
          //

          //@cond

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

          protected:
          AcidDissociationConstant_sequence AcidDissociationConstant_;
          ::xsd::cxx::tree::one< BindingProtein_type > BindingProtein_;
          ::xsd::cxx::tree::one< BloodPlasmaRatio_type > BloodPlasmaRatio_;
          ::xsd::cxx::tree::one< FractionUnboundInPlasma_type > FractionUnboundInPlasma_;
          ::xsd::cxx::tree::one< IonicState_type > IonicState_;
          ::xsd::cxx::tree::one< LogP_type > LogP_;
          HydrogenBondCount_optional HydrogenBondCount_;
          PolarSurfaceArea_optional PolarSurfaceArea_;

          //@endcond
        };

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

          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::ScalarData PartitionCoefficient_type;

          typedef ::xsd::cxx::tree::optional< PartitionCoefficient_type > PartitionCoefficient_optional;

          typedef ::xsd::cxx::tree::traits< PartitionCoefficient_type, char > PartitionCoefficient_traits;

          const PartitionCoefficient_optional&
          PartitionCoefficient () const;

          PartitionCoefficient_optional&
          PartitionCoefficient ();

          void
          PartitionCoefficient (const PartitionCoefficient_type& x);

          void
          PartitionCoefficient (const PartitionCoefficient_optional& x);

          void
          PartitionCoefficient (::std::unique_ptr< PartitionCoefficient_type > p);



          SubstanceTissuePharmacokineticsData ();

          SubstanceTissuePharmacokineticsData (const Name_type&);

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

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

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

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

          SubstanceTissuePharmacokineticsData&
          operator= (const SubstanceTissuePharmacokineticsData& x);


          virtual 
          ~SubstanceTissuePharmacokineticsData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Name_type > Name_;
          PartitionCoefficient_optional PartitionCoefficient_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::traits< EffectSiteRateConstant_type, char > EffectSiteRateConstant_traits;

          const EffectSiteRateConstant_type&
          EffectSiteRateConstant () const;

          EffectSiteRateConstant_type&
          EffectSiteRateConstant ();

          void
          EffectSiteRateConstant (const EffectSiteRateConstant_type& x);

          void
          EffectSiteRateConstant (::std::unique_ptr< EffectSiteRateConstant_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData EMaxShapeParameter_type;

          typedef ::xsd::cxx::tree::traits< EMaxShapeParameter_type, char > EMaxShapeParameter_traits;

          const EMaxShapeParameter_type&
          EMaxShapeParameter () const;

          EMaxShapeParameter_type&
          EMaxShapeParameter ();

          void
          EMaxShapeParameter (const EMaxShapeParameter_type& x);

          void
          EMaxShapeParameter (::std::unique_ptr< EMaxShapeParameter_type > p);



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

          typedef ::xsd::cxx::tree::traits< AntibacterialEffect_type, char > AntibacterialEffect_traits;

          const AntibacterialEffect_type&
          AntibacterialEffect () const;

          AntibacterialEffect_type&
          AntibacterialEffect ();

          void
          AntibacterialEffect (const AntibacterialEffect_type& x);

          void
          AntibacterialEffect (::std::unique_ptr< AntibacterialEffect_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData Bronchodilation_type;

          typedef ::xsd::cxx::tree::traits< Bronchodilation_type, char > Bronchodilation_traits;

          const Bronchodilation_type&
          Bronchodilation () const;

          Bronchodilation_type&
          Bronchodilation ();

          void
          Bronchodilation (const Bronchodilation_type& x);

          void
          Bronchodilation (::std::unique_ptr< Bronchodilation_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData CentralNervousModifier_type;

          typedef ::xsd::cxx::tree::traits< CentralNervousModifier_type, char > CentralNervousModifier_traits;

          const CentralNervousModifier_type&
          CentralNervousModifier () const;

          CentralNervousModifier_type&
          CentralNervousModifier ();

          void
          CentralNervousModifier (const CentralNervousModifier_type& x);

          void
          CentralNervousModifier (::std::unique_ptr< CentralNervousModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData DiastolicPressureModifier_type;

          typedef ::xsd::cxx::tree::traits< DiastolicPressureModifier_type, char > DiastolicPressureModifier_traits;

          const DiastolicPressureModifier_type&
          DiastolicPressureModifier () const;

          DiastolicPressureModifier_type&
          DiastolicPressureModifier ();

          void
          DiastolicPressureModifier (const DiastolicPressureModifier_type& x);

          void
          DiastolicPressureModifier (::std::unique_ptr< DiastolicPressureModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData FeverModifier_type;

          typedef ::xsd::cxx::tree::traits< FeverModifier_type, char > FeverModifier_traits;

          const FeverModifier_type&
          FeverModifier () const;

          FeverModifier_type&
          FeverModifier ();

          void
          FeverModifier (const FeverModifier_type& x);

          void
          FeverModifier (::std::unique_ptr< FeverModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData HeartRateModifier_type;

          typedef ::xsd::cxx::tree::traits< HeartRateModifier_type, char > HeartRateModifier_traits;

          const HeartRateModifier_type&
          HeartRateModifier () const;

          HeartRateModifier_type&
          HeartRateModifier ();

          void
          HeartRateModifier (const HeartRateModifier_type& x);

          void
          HeartRateModifier (::std::unique_ptr< HeartRateModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData HemorrhageModifier_type;

          typedef ::xsd::cxx::tree::traits< HemorrhageModifier_type, char > HemorrhageModifier_traits;

          const HemorrhageModifier_type&
          HemorrhageModifier () const;

          HemorrhageModifier_type&
          HemorrhageModifier ();

          void
          HemorrhageModifier (const HemorrhageModifier_type& x);

          void
          HemorrhageModifier (::std::unique_ptr< HemorrhageModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData NeuromuscularBlock_type;

          typedef ::xsd::cxx::tree::traits< NeuromuscularBlock_type, char > NeuromuscularBlock_traits;

          const NeuromuscularBlock_type&
          NeuromuscularBlock () const;

          NeuromuscularBlock_type&
          NeuromuscularBlock ();

          void
          NeuromuscularBlock (const NeuromuscularBlock_type& x);

          void
          NeuromuscularBlock (::std::unique_ptr< NeuromuscularBlock_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData PainModifier_type;

          typedef ::xsd::cxx::tree::traits< PainModifier_type, char > PainModifier_traits;

          const PainModifier_type&
          PainModifier () const;

          PainModifier_type&
          PainModifier ();

          void
          PainModifier (const PainModifier_type& x);

          void
          PainModifier (::std::unique_ptr< PainModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData PupilReactivityModifier_type;

          typedef ::xsd::cxx::tree::traits< PupilReactivityModifier_type, char > PupilReactivityModifier_traits;

          const PupilReactivityModifier_type&
          PupilReactivityModifier () const;

          PupilReactivityModifier_type&
          PupilReactivityModifier ();

          void
          PupilReactivityModifier (const PupilReactivityModifier_type& x);

          void
          PupilReactivityModifier (::std::unique_ptr< PupilReactivityModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData PupilSizeModifier_type;

          typedef ::xsd::cxx::tree::traits< PupilSizeModifier_type, char > PupilSizeModifier_traits;

          const PupilSizeModifier_type&
          PupilSizeModifier () const;

          PupilSizeModifier_type&
          PupilSizeModifier ();

          void
          PupilSizeModifier (const PupilSizeModifier_type& x);

          void
          PupilSizeModifier (::std::unique_ptr< PupilSizeModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData RespirationRateModifier_type;

          typedef ::xsd::cxx::tree::traits< RespirationRateModifier_type, char > RespirationRateModifier_traits;

          const RespirationRateModifier_type&
          RespirationRateModifier () const;

          RespirationRateModifier_type&
          RespirationRateModifier ();

          void
          RespirationRateModifier (const RespirationRateModifier_type& x);

          void
          RespirationRateModifier (::std::unique_ptr< RespirationRateModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData Sedation_type;

          typedef ::xsd::cxx::tree::traits< Sedation_type, char > Sedation_traits;

          const Sedation_type&
          Sedation () const;

          Sedation_type&
          Sedation ();

          void
          Sedation (const Sedation_type& x);

          void
          Sedation (::std::unique_ptr< Sedation_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData SystolicPressureModifier_type;

          typedef ::xsd::cxx::tree::traits< SystolicPressureModifier_type, char > SystolicPressureModifier_traits;

          const SystolicPressureModifier_type&
          SystolicPressureModifier () const;

          SystolicPressureModifier_type&
          SystolicPressureModifier ();

          void
          SystolicPressureModifier (const SystolicPressureModifier_type& x);

          void
          SystolicPressureModifier (::std::unique_ptr< SystolicPressureModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData TidalVolumeModifier_type;

          typedef ::xsd::cxx::tree::traits< TidalVolumeModifier_type, char > TidalVolumeModifier_traits;

          const TidalVolumeModifier_type&
          TidalVolumeModifier () const;

          TidalVolumeModifier_type&
          TidalVolumeModifier ();

          void
          TidalVolumeModifier (const TidalVolumeModifier_type& x);

          void
          TidalVolumeModifier (::std::unique_ptr< TidalVolumeModifier_type > p);



          typedef ::mil::tatrc::physiology::datamodel::PharmacodynamicModifierData TubularPermeabilityModifier_type;

          typedef ::xsd::cxx::tree::traits< TubularPermeabilityModifier_type, char > TubularPermeabilityModifier_traits;

          const TubularPermeabilityModifier_type&
          TubularPermeabilityModifier () const;

          TubularPermeabilityModifier_type&
          TubularPermeabilityModifier ();

          void
          TubularPermeabilityModifier (const TubularPermeabilityModifier_type& x);

          void
          TubularPermeabilityModifier (::std::unique_ptr< TubularPermeabilityModifier_type > p);



          SubstancePharmacodynamicsData ();

          SubstancePharmacodynamicsData (const EffectSiteRateConstant_type&,
                                         const EMaxShapeParameter_type&,
                                         const AntibacterialEffect_type&,
                                         const Bronchodilation_type&,
                                         const CentralNervousModifier_type&,
                                         const DiastolicPressureModifier_type&,
                                         const FeverModifier_type&,
                                         const HeartRateModifier_type&,
                                         const HemorrhageModifier_type&,
                                         const NeuromuscularBlock_type&,
                                         const PainModifier_type&,
                                         const PupilReactivityModifier_type&,
                                         const PupilSizeModifier_type&,
                                         const RespirationRateModifier_type&,
                                         const Sedation_type&,
                                         const SystolicPressureModifier_type&,
                                         const TidalVolumeModifier_type&,
                                         const TubularPermeabilityModifier_type&);

          SubstancePharmacodynamicsData (::std::unique_ptr< EffectSiteRateConstant_type >,
                                         ::std::unique_ptr< EMaxShapeParameter_type >,
                                         ::std::unique_ptr< AntibacterialEffect_type >,
                                         ::std::unique_ptr< Bronchodilation_type >,
                                         ::std::unique_ptr< CentralNervousModifier_type >,
                                         ::std::unique_ptr< DiastolicPressureModifier_type >,
                                         ::std::unique_ptr< FeverModifier_type >,
                                         ::std::unique_ptr< HeartRateModifier_type >,
                                         ::std::unique_ptr< HemorrhageModifier_type >,
                                         ::std::unique_ptr< NeuromuscularBlock_type >,
                                         ::std::unique_ptr< PainModifier_type >,
                                         ::std::unique_ptr< PupilReactivityModifier_type >,
                                         ::std::unique_ptr< PupilSizeModifier_type >,
                                         ::std::unique_ptr< RespirationRateModifier_type >,
                                         ::std::unique_ptr< Sedation_type >,
                                         ::std::unique_ptr< SystolicPressureModifier_type >,
                                         ::std::unique_ptr< TidalVolumeModifier_type >,
                                         ::std::unique_ptr< TubularPermeabilityModifier_type >);

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

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

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

          SubstancePharmacodynamicsData&
          operator= (const SubstancePharmacodynamicsData& x);


          virtual 
          ~SubstancePharmacodynamicsData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< EffectSiteRateConstant_type > EffectSiteRateConstant_;
          ::xsd::cxx::tree::one< EMaxShapeParameter_type > EMaxShapeParameter_;
          ::xsd::cxx::tree::one< AntibacterialEffect_type > AntibacterialEffect_;
          ::xsd::cxx::tree::one< Bronchodilation_type > Bronchodilation_;
          ::xsd::cxx::tree::one< CentralNervousModifier_type > CentralNervousModifier_;
          ::xsd::cxx::tree::one< DiastolicPressureModifier_type > DiastolicPressureModifier_;
          ::xsd::cxx::tree::one< FeverModifier_type > FeverModifier_;
          ::xsd::cxx::tree::one< HeartRateModifier_type > HeartRateModifier_;
          ::xsd::cxx::tree::one< HemorrhageModifier_type > HemorrhageModifier_;
          ::xsd::cxx::tree::one< NeuromuscularBlock_type > NeuromuscularBlock_;
          ::xsd::cxx::tree::one< PainModifier_type > PainModifier_;
          ::xsd::cxx::tree::one< PupilReactivityModifier_type > PupilReactivityModifier_;
          ::xsd::cxx::tree::one< PupilSizeModifier_type > PupilSizeModifier_;
          ::xsd::cxx::tree::one< RespirationRateModifier_type > RespirationRateModifier_;
          ::xsd::cxx::tree::one< Sedation_type > Sedation_;
          ::xsd::cxx::tree::one< SystolicPressureModifier_type > SystolicPressureModifier_;
          ::xsd::cxx::tree::one< TidalVolumeModifier_type > TidalVolumeModifier_;
          ::xsd::cxx::tree::one< TubularPermeabilityModifier_type > TubularPermeabilityModifier_;

          //@endcond
        };

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

          typedef ::mil::tatrc::physiology::datamodel::Systemic Systemic_type;

          typedef ::xsd::cxx::tree::optional< Systemic_type > Systemic_optional;

          typedef ::xsd::cxx::tree::traits< Systemic_type, char > Systemic_traits;

          const Systemic_optional&
          Systemic () const;

          Systemic_optional&
          Systemic ();

          void
          Systemic (const Systemic_type& x);

          void
          Systemic (const Systemic_optional& x);

          void
          Systemic (::std::unique_ptr< Systemic_type > p);



          typedef ::mil::tatrc::physiology::datamodel::RenalDynamics RenalDynamics_type;

          typedef ::xsd::cxx::tree::optional< RenalDynamics_type > RenalDynamics_optional;

          typedef ::xsd::cxx::tree::traits< RenalDynamics_type, char > RenalDynamics_traits;

          const RenalDynamics_optional&
          RenalDynamics () const;

          RenalDynamics_optional&
          RenalDynamics ();

          void
          RenalDynamics (const RenalDynamics_type& x);

          void
          RenalDynamics (const RenalDynamics_optional& x);

          void
          RenalDynamics (::std::unique_ptr< RenalDynamics_type > p);



          typedef ::mil::tatrc::physiology::datamodel::CellRegulation CellRegulation_type;

          typedef ::xsd::cxx::tree::optional< CellRegulation_type > CellRegulation_optional;

          typedef ::xsd::cxx::tree::traits< CellRegulation_type, char > CellRegulation_traits;

          const CellRegulation_optional&
          CellRegulation () const;

          CellRegulation_optional&
          CellRegulation ();

          void
          CellRegulation (const CellRegulation_type& x);

          void
          CellRegulation (const CellRegulation_optional& x);

          void
          CellRegulation (::std::unique_ptr< CellRegulation_type > p);



          SubstanceClearanceData ();

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

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

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

          SubstanceClearanceData&
          operator= (const SubstanceClearanceData& x);


          virtual 
          ~SubstanceClearanceData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Systemic_optional Systemic_;
          RenalDynamics_optional RenalDynamics_;
          CellRegulation_optional CellRegulation_;

          //@endcond
        };

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

          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::enumSubstanceClass Classification_type;

          typedef ::xsd::cxx::tree::optional< Classification_type > Classification_optional;

          typedef ::xsd::cxx::tree::traits< Classification_type, char > Classification_traits;

          const Classification_optional&
          Classification () const;

          Classification_optional&
          Classification ();

          void
          Classification (const Classification_type& x);

          void
          Classification (const Classification_optional& x);

          void
          Classification (::std::unique_ptr< Classification_type > p);



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

          typedef ::xsd::cxx::tree::optional< Density_type > Density_optional;

          typedef ::xsd::cxx::tree::traits< Density_type, char > Density_traits;

          const Density_optional&
          Density () const;

          Density_optional&
          Density ();

          void
          Density (const Density_type& x);

          void
          Density (const Density_optional& x);

          void
          Density (::std::unique_ptr< Density_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerAmountData MolarMass_type;

          typedef ::xsd::cxx::tree::optional< MolarMass_type > MolarMass_optional;

          typedef ::xsd::cxx::tree::traits< MolarMass_type, char > MolarMass_traits;

          const MolarMass_optional&
          MolarMass () const;

          MolarMass_optional&
          MolarMass ();

          void
          MolarMass (const MolarMass_type& x);

          void
          MolarMass (const MolarMass_optional& x);

          void
          MolarMass (::std::unique_ptr< MolarMass_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumSubstanceState State_type;

          typedef ::xsd::cxx::tree::optional< State_type > State_optional;

          typedef ::xsd::cxx::tree::traits< State_type, char > State_traits;

          const State_optional&
          State () const;

          State_optional&
          State ();

          void
          State (const State_type& x);

          void
          State (const State_optional& x);

          void
          State (::std::unique_ptr< State_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerAreaTimeData MaximumDiffusionFlux_type;

          typedef ::xsd::cxx::tree::optional< MaximumDiffusionFlux_type > MaximumDiffusionFlux_optional;

          typedef ::xsd::cxx::tree::traits< MaximumDiffusionFlux_type, char > MaximumDiffusionFlux_traits;

          const MaximumDiffusionFlux_optional&
          MaximumDiffusionFlux () const;

          MaximumDiffusionFlux_optional&
          MaximumDiffusionFlux ();

          void
          MaximumDiffusionFlux (const MaximumDiffusionFlux_type& x);

          void
          MaximumDiffusionFlux (const MaximumDiffusionFlux_optional& x);

          void
          MaximumDiffusionFlux (::std::unique_ptr< MaximumDiffusionFlux_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData MichaelisCoefficient_type;

          typedef ::xsd::cxx::tree::optional< MichaelisCoefficient_type > MichaelisCoefficient_optional;

          typedef ::xsd::cxx::tree::traits< MichaelisCoefficient_type, char > MichaelisCoefficient_traits;

          const MichaelisCoefficient_optional&
          MichaelisCoefficient () const;

          MichaelisCoefficient_optional&
          MichaelisCoefficient ();

          void
          MichaelisCoefficient (const MichaelisCoefficient_type& x);

          void
          MichaelisCoefficient (const MichaelisCoefficient_optional& x);

          void
          MichaelisCoefficient (::std::unique_ptr< MichaelisCoefficient_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricResistanceData MembraneResistance_type;

          typedef ::xsd::cxx::tree::optional< MembraneResistance_type > MembraneResistance_optional;

          typedef ::xsd::cxx::tree::traits< MembraneResistance_type, char > MembraneResistance_traits;

          const MembraneResistance_optional&
          MembraneResistance () const;

          MembraneResistance_optional&
          MembraneResistance ();

          void
          MembraneResistance (const MembraneResistance_type& x);

          void
          MembraneResistance (const MembraneResistance_optional& x);

          void
          MembraneResistance (::std::unique_ptr< MembraneResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::SubstanceAerosolizationData Aerosolization_type;

          typedef ::xsd::cxx::tree::optional< Aerosolization_type > Aerosolization_optional;

          typedef ::xsd::cxx::tree::traits< Aerosolization_type, char > Aerosolization_traits;

          const Aerosolization_optional&
          Aerosolization () const;

          Aerosolization_optional&
          Aerosolization ();

          void
          Aerosolization (const Aerosolization_type& x);

          void
          Aerosolization (const Aerosolization_optional& x);

          void
          Aerosolization (::std::unique_ptr< Aerosolization_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarTimeMassPerVolumeData AreaUnderCurve_type;

          typedef ::xsd::cxx::tree::optional< AreaUnderCurve_type > AreaUnderCurve_optional;

          typedef ::xsd::cxx::tree::traits< AreaUnderCurve_type, char > AreaUnderCurve_traits;

          const AreaUnderCurve_optional&
          AreaUnderCurve () const;

          AreaUnderCurve_optional&
          AreaUnderCurve ();

          void
          AreaUnderCurve (const AreaUnderCurve_type& x);

          void
          AreaUnderCurve (const AreaUnderCurve_optional& x);

          void
          AreaUnderCurve (::std::unique_ptr< AreaUnderCurve_type > p);



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

          typedef ::xsd::cxx::tree::optional< BloodConcentration_type > BloodConcentration_optional;

          typedef ::xsd::cxx::tree::traits< BloodConcentration_type, char > BloodConcentration_traits;

          const BloodConcentration_optional&
          BloodConcentration () const;

          BloodConcentration_optional&
          BloodConcentration ();

          void
          BloodConcentration (const BloodConcentration_type& x);

          void
          BloodConcentration (const BloodConcentration_optional& x);

          void
          BloodConcentration (::std::unique_ptr< BloodConcentration_type > p);



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

          typedef ::xsd::cxx::tree::optional< EffectSiteConcentration_type > EffectSiteConcentration_optional;

          typedef ::xsd::cxx::tree::traits< EffectSiteConcentration_type, char > EffectSiteConcentration_traits;

          const EffectSiteConcentration_optional&
          EffectSiteConcentration () const;

          EffectSiteConcentration_optional&
          EffectSiteConcentration ();

          void
          EffectSiteConcentration (const EffectSiteConcentration_type& x);

          void
          EffectSiteConcentration (const EffectSiteConcentration_optional& x);

          void
          EffectSiteConcentration (::std::unique_ptr< EffectSiteConcentration_type > p);



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

          typedef ::xsd::cxx::tree::optional< MassInBody_type > MassInBody_optional;

          typedef ::xsd::cxx::tree::traits< MassInBody_type, char > MassInBody_traits;

          const MassInBody_optional&
          MassInBody () const;

          MassInBody_optional&
          MassInBody ();

          void
          MassInBody (const MassInBody_type& x);

          void
          MassInBody (const MassInBody_optional& x);

          void
          MassInBody (::std::unique_ptr< MassInBody_type > p);



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

          typedef ::xsd::cxx::tree::optional< MassInBlood_type > MassInBlood_optional;

          typedef ::xsd::cxx::tree::traits< MassInBlood_type, char > MassInBlood_traits;

          const MassInBlood_optional&
          MassInBlood () const;

          MassInBlood_optional&
          MassInBlood ();

          void
          MassInBlood (const MassInBlood_type& x);

          void
          MassInBlood (const MassInBlood_optional& x);

          void
          MassInBlood (::std::unique_ptr< MassInBlood_type > p);



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

          typedef ::xsd::cxx::tree::optional< MassInTissue_type > MassInTissue_optional;

          typedef ::xsd::cxx::tree::traits< MassInTissue_type, char > MassInTissue_traits;

          const MassInTissue_optional&
          MassInTissue () const;

          MassInTissue_optional&
          MassInTissue ();

          void
          MassInTissue (const MassInTissue_type& x);

          void
          MassInTissue (const MassInTissue_optional& x);

          void
          MassInTissue (::std::unique_ptr< MassInTissue_type > p);



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

          typedef ::xsd::cxx::tree::optional< PlasmaConcentration_type > PlasmaConcentration_optional;

          typedef ::xsd::cxx::tree::traits< PlasmaConcentration_type, char > PlasmaConcentration_traits;

          const PlasmaConcentration_optional&
          PlasmaConcentration () const;

          PlasmaConcentration_optional&
          PlasmaConcentration ();

          void
          PlasmaConcentration (const PlasmaConcentration_type& x);

          void
          PlasmaConcentration (const PlasmaConcentration_optional& x);

          void
          PlasmaConcentration (::std::unique_ptr< PlasmaConcentration_type > p);



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

          typedef ::xsd::cxx::tree::optional< SystemicMassCleared_type > SystemicMassCleared_optional;

          typedef ::xsd::cxx::tree::traits< SystemicMassCleared_type, char > SystemicMassCleared_traits;

          const SystemicMassCleared_optional&
          SystemicMassCleared () const;

          SystemicMassCleared_optional&
          SystemicMassCleared ();

          void
          SystemicMassCleared (const SystemicMassCleared_type& x);

          void
          SystemicMassCleared (const SystemicMassCleared_optional& x);

          void
          SystemicMassCleared (::std::unique_ptr< SystemicMassCleared_type > p);



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

          typedef ::xsd::cxx::tree::optional< TissueConcentration_type > TissueConcentration_optional;

          typedef ::xsd::cxx::tree::traits< TissueConcentration_type, char > TissueConcentration_traits;

          const TissueConcentration_optional&
          TissueConcentration () const;

          TissueConcentration_optional&
          TissueConcentration ();

          void
          TissueConcentration (const TissueConcentration_type& x);

          void
          TissueConcentration (const TissueConcentration_optional& x);

          void
          TissueConcentration (::std::unique_ptr< TissueConcentration_type > p);



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

          typedef ::xsd::cxx::tree::optional< AlveolarTransfer_type > AlveolarTransfer_optional;

          typedef ::xsd::cxx::tree::traits< AlveolarTransfer_type, char > AlveolarTransfer_traits;

          const AlveolarTransfer_optional&
          AlveolarTransfer () const;

          AlveolarTransfer_optional&
          AlveolarTransfer ();

          void
          AlveolarTransfer (const AlveolarTransfer_type& x);

          void
          AlveolarTransfer (const AlveolarTransfer_optional& x);

          void
          AlveolarTransfer (::std::unique_ptr< AlveolarTransfer_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimePressureData DiffusingCapacity_type;

          typedef ::xsd::cxx::tree::optional< DiffusingCapacity_type > DiffusingCapacity_optional;

          typedef ::xsd::cxx::tree::traits< DiffusingCapacity_type, char > DiffusingCapacity_traits;

          const DiffusingCapacity_optional&
          DiffusingCapacity () const;

          DiffusingCapacity_optional&
          DiffusingCapacity ();

          void
          DiffusingCapacity (const DiffusingCapacity_type& x);

          void
          DiffusingCapacity (const DiffusingCapacity_optional& x);

          void
          DiffusingCapacity (::std::unique_ptr< DiffusingCapacity_type > p);



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

          typedef ::xsd::cxx::tree::optional< EndTidalFraction_type > EndTidalFraction_optional;

          typedef ::xsd::cxx::tree::traits< EndTidalFraction_type, char > EndTidalFraction_traits;

          const EndTidalFraction_optional&
          EndTidalFraction () const;

          EndTidalFraction_optional&
          EndTidalFraction ();

          void
          EndTidalFraction (const EndTidalFraction_type& x);

          void
          EndTidalFraction (const EndTidalFraction_optional& x);

          void
          EndTidalFraction (::std::unique_ptr< EndTidalFraction_type > p);



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

          typedef ::xsd::cxx::tree::optional< EndTidalPressure_type > EndTidalPressure_optional;

          typedef ::xsd::cxx::tree::traits< EndTidalPressure_type, char > EndTidalPressure_traits;

          const EndTidalPressure_optional&
          EndTidalPressure () const;

          EndTidalPressure_optional&
          EndTidalPressure ();

          void
          EndTidalPressure (const EndTidalPressure_type& x);

          void
          EndTidalPressure (const EndTidalPressure_optional& x);

          void
          EndTidalPressure (::std::unique_ptr< EndTidalPressure_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData RelativeDiffusionCoefficient_type;

          typedef ::xsd::cxx::tree::optional< RelativeDiffusionCoefficient_type > RelativeDiffusionCoefficient_optional;

          typedef ::xsd::cxx::tree::traits< RelativeDiffusionCoefficient_type, char > RelativeDiffusionCoefficient_traits;

          const RelativeDiffusionCoefficient_optional&
          RelativeDiffusionCoefficient () const;

          RelativeDiffusionCoefficient_optional&
          RelativeDiffusionCoefficient ();

          void
          RelativeDiffusionCoefficient (const RelativeDiffusionCoefficient_type& x);

          void
          RelativeDiffusionCoefficient (const RelativeDiffusionCoefficient_optional& x);

          void
          RelativeDiffusionCoefficient (::std::unique_ptr< RelativeDiffusionCoefficient_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarInversePressureData SolubilityCoefficient_type;

          typedef ::xsd::cxx::tree::optional< SolubilityCoefficient_type > SolubilityCoefficient_optional;

          typedef ::xsd::cxx::tree::traits< SolubilityCoefficient_type, char > SolubilityCoefficient_traits;

          const SolubilityCoefficient_optional&
          SolubilityCoefficient () const;

          SolubilityCoefficient_optional&
          SolubilityCoefficient ();

          void
          SolubilityCoefficient (const SolubilityCoefficient_type& x);

          void
          SolubilityCoefficient (const SolubilityCoefficient_optional& x);

          void
          SolubilityCoefficient (::std::unique_ptr< SolubilityCoefficient_type > p);



          typedef ::mil::tatrc::physiology::datamodel::SubstanceClearanceData Clearance_type;

          typedef ::xsd::cxx::tree::optional< Clearance_type > Clearance_optional;

          typedef ::xsd::cxx::tree::traits< Clearance_type, char > Clearance_traits;

          const Clearance_optional&
          Clearance () const;

          Clearance_optional&
          Clearance ();

          void
          Clearance (const Clearance_type& x);

          void
          Clearance (const Clearance_optional& x);

          void
          Clearance (::std::unique_ptr< Clearance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::SubstancePharmacokineticsData Pharmacokinetics_type;

          typedef ::xsd::cxx::tree::optional< Pharmacokinetics_type > Pharmacokinetics_optional;

          typedef ::xsd::cxx::tree::traits< Pharmacokinetics_type, char > Pharmacokinetics_traits;

          const Pharmacokinetics_optional&
          Pharmacokinetics () const;

          Pharmacokinetics_optional&
          Pharmacokinetics ();

          void
          Pharmacokinetics (const Pharmacokinetics_type& x);

          void
          Pharmacokinetics (const Pharmacokinetics_optional& x);

          void
          Pharmacokinetics (::std::unique_ptr< Pharmacokinetics_type > p);



          typedef ::mil::tatrc::physiology::datamodel::SubstancePharmacodynamicsData Pharmacodynamics_type;

          typedef ::xsd::cxx::tree::optional< Pharmacodynamics_type > Pharmacodynamics_optional;

          typedef ::xsd::cxx::tree::traits< Pharmacodynamics_type, char > Pharmacodynamics_traits;

          const Pharmacodynamics_optional&
          Pharmacodynamics () const;

          Pharmacodynamics_optional&
          Pharmacodynamics ();

          void
          Pharmacodynamics (const Pharmacodynamics_type& x);

          void
          Pharmacodynamics (const Pharmacodynamics_optional& x);

          void
          Pharmacodynamics (::std::unique_ptr< Pharmacodynamics_type > p);



          SubstanceData ();

          SubstanceData (const Name_type&);

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

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

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

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

          SubstanceData&
          operator= (const SubstanceData& x);


          virtual 
          ~SubstanceData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Name_type > Name_;
          Classification_optional Classification_;
          Density_optional Density_;
          MolarMass_optional MolarMass_;
          State_optional State_;
          MaximumDiffusionFlux_optional MaximumDiffusionFlux_;
          MichaelisCoefficient_optional MichaelisCoefficient_;
          MembraneResistance_optional MembraneResistance_;
          Aerosolization_optional Aerosolization_;
          AreaUnderCurve_optional AreaUnderCurve_;
          BloodConcentration_optional BloodConcentration_;
          EffectSiteConcentration_optional EffectSiteConcentration_;
          MassInBody_optional MassInBody_;
          MassInBlood_optional MassInBlood_;
          MassInTissue_optional MassInTissue_;
          PlasmaConcentration_optional PlasmaConcentration_;
          SystemicMassCleared_optional SystemicMassCleared_;
          TissueConcentration_optional TissueConcentration_;
          AlveolarTransfer_optional AlveolarTransfer_;
          DiffusingCapacity_optional DiffusingCapacity_;
          EndTidalFraction_optional EndTidalFraction_;
          EndTidalPressure_optional EndTidalPressure_;
          RelativeDiffusionCoefficient_optional RelativeDiffusionCoefficient_;
          SolubilityCoefficient_optional SolubilityCoefficient_;
          Clearance_optional Clearance_;
          Pharmacokinetics_optional Pharmacokinetics_;
          Pharmacodynamics_optional Pharmacodynamics_;

          //@endcond
        };

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

          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::enumSubstanceClass Classification_type;

          typedef ::xsd::cxx::tree::optional< Classification_type > Classification_optional;

          typedef ::xsd::cxx::tree::traits< Classification_type, char > Classification_traits;

          const Classification_optional&
          Classification () const;

          Classification_optional&
          Classification ();

          void
          Classification (const Classification_type& x);

          void
          Classification (const Classification_optional& x);

          void
          Classification (::std::unique_ptr< Classification_type > p);



          typedef ::xml_schema::boolean BloodRHFactor_type;

          typedef ::xsd::cxx::tree::optional< BloodRHFactor_type > BloodRHFactor_optional;

          typedef ::xsd::cxx::tree::traits< BloodRHFactor_type, char > BloodRHFactor_traits;

          const BloodRHFactor_optional&
          BloodRHFactor () const;

          BloodRHFactor_optional&
          BloodRHFactor ();

          void
          BloodRHFactor (const BloodRHFactor_type& x);

          void
          BloodRHFactor (const BloodRHFactor_optional& x);



          typedef ::mil::tatrc::physiology::datamodel::SubstanceConcentrationData Component_type;

          typedef ::xsd::cxx::tree::sequence< Component_type > Component_sequence;

          typedef Component_sequence::iterator Component_iterator;

          typedef Component_sequence::const_iterator Component_const_iterator;

          typedef ::xsd::cxx::tree::traits< Component_type, char > Component_traits;

          const Component_sequence&
          Component () const;

          Component_sequence&
          Component ();

          void
          Component (const Component_sequence& s);



          SubstanceCompoundData ();

          SubstanceCompoundData (const Name_type&);

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

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

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

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

          SubstanceCompoundData&
          operator= (const SubstanceCompoundData& x);


          virtual 
          ~SubstanceCompoundData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Name_type > Name_;
          Classification_optional Classification_;
          BloodRHFactor_optional BloodRHFactor_;
          Component_sequence Component_;

          //@endcond
        };

        class BIOGEARS_CDM_API SubstanceFractionData: public ::xml_schema::type
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< FractionAmount_type, char > FractionAmount_traits;

          const FractionAmount_type&
          FractionAmount () const;

          FractionAmount_type&
          FractionAmount ();

          void
          FractionAmount (const FractionAmount_type& x);

          void
          FractionAmount (::std::unique_ptr< FractionAmount_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);



          SubstanceFractionData ();

          SubstanceFractionData (const FractionAmount_type&,
                                 const Name_type&);

          SubstanceFractionData (::std::unique_ptr< FractionAmount_type >,
                                 const Name_type&);

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

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

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

          SubstanceFractionData&
          operator= (const SubstanceFractionData& x);


          virtual 
          ~SubstanceFractionData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< FractionAmount_type > FractionAmount_;
          ::xsd::cxx::tree::one< Name_type > Name_;

          //@endcond
        };

        class BIOGEARS_CDM_API SubstanceConcentrationData: public ::xml_schema::type
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< Concentration_type, char > Concentration_traits;

          const Concentration_type&
          Concentration () const;

          Concentration_type&
          Concentration ();

          void
          Concentration (const Concentration_type& x);

          void
          Concentration (::std::unique_ptr< Concentration_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);



          SubstanceConcentrationData ();

          SubstanceConcentrationData (const Concentration_type&,
                                      const Name_type&);

          SubstanceConcentrationData (::std::unique_ptr< Concentration_type >,
                                      const Name_type&);

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

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

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

          SubstanceConcentrationData&
          operator= (const SubstanceConcentrationData& x);


          virtual 
          ~SubstanceConcentrationData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Concentration_type > Concentration_;
          ::xsd::cxx::tree::one< Name_type > Name_;

          //@endcond
        };

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

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

          typedef ::xsd::cxx::tree::traits< EMax_type, char > EMax_traits;

          const EMax_type&
          EMax () const;

          EMax_type&
          EMax ();

          void
          EMax (const EMax_type& x);

          void
          EMax (::std::unique_ptr< EMax_type > p);



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

          typedef ::xsd::cxx::tree::traits< EC50_type, char > EC50_traits;

          const EC50_type&
          EC50 () const;

          EC50_type&
          EC50 ();

          void
          EC50 (const EC50_type& x);

          void
          EC50 (::std::unique_ptr< EC50_type > p);



          PharmacodynamicModifierData ();

          PharmacodynamicModifierData (const EMax_type&,
                                       const EC50_type&);

          PharmacodynamicModifierData (::std::unique_ptr< EMax_type >,
                                       ::std::unique_ptr< EC50_type >);

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

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

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

          PharmacodynamicModifierData&
          operator= (const PharmacodynamicModifierData& x);


          virtual 
          ~PharmacodynamicModifierData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< EMax_type > EMax_;
          ::xsd::cxx::tree::one< EC50_type > EC50_;

          //@endcond
        };

        class BIOGEARS_CDM_API Systemic: public ::xml_schema::type
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< FractionExcretedInFeces_type, char > FractionExcretedInFeces_traits;

          const FractionExcretedInFeces_type&
          FractionExcretedInFeces () const;

          FractionExcretedInFeces_type&
          FractionExcretedInFeces ();

          void
          FractionExcretedInFeces (const FractionExcretedInFeces_type& x);

          void
          FractionExcretedInFeces (::std::unique_ptr< FractionExcretedInFeces_type > p);



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

          typedef ::xsd::cxx::tree::optional< FractionExcretedInUrine_type > FractionExcretedInUrine_optional;

          typedef ::xsd::cxx::tree::traits< FractionExcretedInUrine_type, char > FractionExcretedInUrine_traits;

          const FractionExcretedInUrine_optional&
          FractionExcretedInUrine () const;

          FractionExcretedInUrine_optional&
          FractionExcretedInUrine ();

          void
          FractionExcretedInUrine (const FractionExcretedInUrine_type& x);

          void
          FractionExcretedInUrine (const FractionExcretedInUrine_optional& x);

          void
          FractionExcretedInUrine (::std::unique_ptr< FractionExcretedInUrine_type > p);



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

          typedef ::xsd::cxx::tree::optional< FractionMetabolizedInGut_type > FractionMetabolizedInGut_optional;

          typedef ::xsd::cxx::tree::traits< FractionMetabolizedInGut_type, char > FractionMetabolizedInGut_traits;

          const FractionMetabolizedInGut_optional&
          FractionMetabolizedInGut () const;

          FractionMetabolizedInGut_optional&
          FractionMetabolizedInGut ();

          void
          FractionMetabolizedInGut (const FractionMetabolizedInGut_type& x);

          void
          FractionMetabolizedInGut (const FractionMetabolizedInGut_optional& x);

          void
          FractionMetabolizedInGut (::std::unique_ptr< FractionMetabolizedInGut_type > p);



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

          typedef ::xsd::cxx::tree::traits< FractionUnboundInPlasma_type, char > FractionUnboundInPlasma_traits;

          const FractionUnboundInPlasma_type&
          FractionUnboundInPlasma () const;

          FractionUnboundInPlasma_type&
          FractionUnboundInPlasma ();

          void
          FractionUnboundInPlasma (const FractionUnboundInPlasma_type& x);

          void
          FractionUnboundInPlasma (::std::unique_ptr< FractionUnboundInPlasma_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimeMassData IntrinsicClearance_type;

          typedef ::xsd::cxx::tree::traits< IntrinsicClearance_type, char > IntrinsicClearance_traits;

          const IntrinsicClearance_type&
          IntrinsicClearance () const;

          IntrinsicClearance_type&
          IntrinsicClearance ();

          void
          IntrinsicClearance (const IntrinsicClearance_type& x);

          void
          IntrinsicClearance (::std::unique_ptr< IntrinsicClearance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimeMassData RenalClearance_type;

          typedef ::xsd::cxx::tree::traits< RenalClearance_type, char > RenalClearance_traits;

          const RenalClearance_type&
          RenalClearance () const;

          RenalClearance_type&
          RenalClearance ();

          void
          RenalClearance (const RenalClearance_type& x);

          void
          RenalClearance (::std::unique_ptr< RenalClearance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimeMassData SystemicClearance_type;

          typedef ::xsd::cxx::tree::traits< SystemicClearance_type, char > SystemicClearance_traits;

          const SystemicClearance_type&
          SystemicClearance () const;

          SystemicClearance_type&
          SystemicClearance ();

          void
          SystemicClearance (const SystemicClearance_type& x);

          void
          SystemicClearance (::std::unique_ptr< SystemicClearance_type > p);



          Systemic ();

          Systemic (const FractionExcretedInFeces_type&,
                    const FractionUnboundInPlasma_type&,
                    const IntrinsicClearance_type&,
                    const RenalClearance_type&,
                    const SystemicClearance_type&);

          Systemic (::std::unique_ptr< FractionExcretedInFeces_type >,
                    ::std::unique_ptr< FractionUnboundInPlasma_type >,
                    ::std::unique_ptr< IntrinsicClearance_type >,
                    ::std::unique_ptr< RenalClearance_type >,
                    ::std::unique_ptr< SystemicClearance_type >);

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

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

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

          Systemic&
          operator= (const Systemic& x);


          virtual 
          ~Systemic ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< FractionExcretedInFeces_type > FractionExcretedInFeces_;
          FractionExcretedInUrine_optional FractionExcretedInUrine_;
          FractionMetabolizedInGut_optional FractionMetabolizedInGut_;
          ::xsd::cxx::tree::one< FractionUnboundInPlasma_type > FractionUnboundInPlasma_;
          ::xsd::cxx::tree::one< IntrinsicClearance_type > IntrinsicClearance_;
          ::xsd::cxx::tree::one< RenalClearance_type > RenalClearance_;
          ::xsd::cxx::tree::one< SystemicClearance_type > SystemicClearance_;

          //@endcond
        };

        class BIOGEARS_CDM_API RenalDynamics: public ::xml_schema::type
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarVolumePerTimeMassData Clearance_type;

          typedef ::xsd::cxx::tree::optional< Clearance_type > Clearance_optional;

          typedef ::xsd::cxx::tree::traits< Clearance_type, char > Clearance_traits;

          const Clearance_optional&
          Clearance () const;

          Clearance_optional&
          Clearance ();

          void
          Clearance (const Clearance_type& x);

          void
          Clearance (const Clearance_optional& x);

          void
          Clearance (::std::unique_ptr< Clearance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::Regulation Regulation_type;

          typedef ::xsd::cxx::tree::optional< Regulation_type > Regulation_optional;

          typedef ::xsd::cxx::tree::traits< Regulation_type, char > Regulation_traits;

          const Regulation_optional&
          Regulation () const;

          Regulation_optional&
          Regulation ();

          void
          Regulation (const Regulation_type& x);

          void
          Regulation (const Regulation_optional& x);

          void
          Regulation (::std::unique_ptr< Regulation_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerTimeData FiltrationRate_type;

          typedef ::xsd::cxx::tree::optional< FiltrationRate_type > FiltrationRate_optional;

          typedef ::xsd::cxx::tree::traits< FiltrationRate_type, char > FiltrationRate_traits;

          const FiltrationRate_optional&
          FiltrationRate () const;

          FiltrationRate_optional&
          FiltrationRate ();

          void
          FiltrationRate (const FiltrationRate_type& x);

          void
          FiltrationRate (const FiltrationRate_optional& x);

          void
          FiltrationRate (::std::unique_ptr< FiltrationRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerTimeData ReabsorptionRate_type;

          typedef ::xsd::cxx::tree::optional< ReabsorptionRate_type > ReabsorptionRate_optional;

          typedef ::xsd::cxx::tree::traits< ReabsorptionRate_type, char > ReabsorptionRate_traits;

          const ReabsorptionRate_optional&
          ReabsorptionRate () const;

          ReabsorptionRate_optional&
          ReabsorptionRate ();

          void
          ReabsorptionRate (const ReabsorptionRate_type& x);

          void
          ReabsorptionRate (const ReabsorptionRate_optional& x);

          void
          ReabsorptionRate (::std::unique_ptr< ReabsorptionRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerTimeData ExcretionRate_type;

          typedef ::xsd::cxx::tree::optional< ExcretionRate_type > ExcretionRate_optional;

          typedef ::xsd::cxx::tree::traits< ExcretionRate_type, char > ExcretionRate_traits;

          const ExcretionRate_optional&
          ExcretionRate () const;

          ExcretionRate_optional&
          ExcretionRate ();

          void
          ExcretionRate (const ExcretionRate_type& x);

          void
          ExcretionRate (const ExcretionRate_optional& x);

          void
          ExcretionRate (::std::unique_ptr< ExcretionRate_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData GlomerularFilterability_type;

          typedef ::xsd::cxx::tree::optional< GlomerularFilterability_type > GlomerularFilterability_optional;

          typedef ::xsd::cxx::tree::traits< GlomerularFilterability_type, char > GlomerularFilterability_traits;

          const GlomerularFilterability_optional&
          GlomerularFilterability () const;

          GlomerularFilterability_optional&
          GlomerularFilterability ();

          void
          GlomerularFilterability (const GlomerularFilterability_type& x);

          void
          GlomerularFilterability (const GlomerularFilterability_optional& x);

          void
          GlomerularFilterability (::std::unique_ptr< GlomerularFilterability_type > p);



          RenalDynamics ();

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

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

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

          RenalDynamics&
          operator= (const RenalDynamics& x);


          virtual 
          ~RenalDynamics ();

          // Implementation.
          //

          //@cond

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

          protected:
          Clearance_optional Clearance_;
          Regulation_optional Regulation_;
          FiltrationRate_optional FiltrationRate_;
          ReabsorptionRate_optional ReabsorptionRate_;
          ExcretionRate_optional ExcretionRate_;
          GlomerularFilterability_optional GlomerularFilterability_;

          //@endcond
        };

        class BIOGEARS_CDM_API CellRegulation: public ::xml_schema::type
        {
          public:

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

          typedef ::xsd::cxx::tree::traits< CellDeathRate_type, char > CellDeathRate_traits;

          const CellDeathRate_type&
          CellDeathRate () const;

          CellDeathRate_type&
          CellDeathRate ();

          void
          CellDeathRate (const CellDeathRate_type& x);

          void
          CellDeathRate (::std::unique_ptr< CellDeathRate_type > p);



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

          typedef ::xsd::cxx::tree::traits< CellBirthRate_type, char > CellBirthRate_traits;

          const CellBirthRate_type&
          CellBirthRate () const;

          CellBirthRate_type&
          CellBirthRate ();

          void
          CellBirthRate (const CellBirthRate_type& x);

          void
          CellBirthRate (::std::unique_ptr< CellBirthRate_type > p);



          CellRegulation ();

          CellRegulation (const CellDeathRate_type&,
                          const CellBirthRate_type&);

          CellRegulation (::std::unique_ptr< CellDeathRate_type >,
                          ::std::unique_ptr< CellBirthRate_type >);

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

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

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

          CellRegulation&
          operator= (const CellRegulation& x);


          virtual 
          ~CellRegulation ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< CellDeathRate_type > CellDeathRate_;
          ::xsd::cxx::tree::one< CellBirthRate_type > CellBirthRate_;

          //@endcond
        };

        class BIOGEARS_CDM_API Regulation: public ::xml_schema::type
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::enumCharge ChargeInBlood_type;

          typedef ::xsd::cxx::tree::traits< ChargeInBlood_type, char > ChargeInBlood_traits;

          const ChargeInBlood_type&
          ChargeInBlood () const;

          ChargeInBlood_type&
          ChargeInBlood ();

          void
          ChargeInBlood (const ChargeInBlood_type& x);

          void
          ChargeInBlood (::std::unique_ptr< ChargeInBlood_type > p);



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

          typedef ::xsd::cxx::tree::traits< FractionUnboundInPlasma_type, char > FractionUnboundInPlasma_traits;

          const FractionUnboundInPlasma_type&
          FractionUnboundInPlasma () const;

          FractionUnboundInPlasma_type&
          FractionUnboundInPlasma ();

          void
          FractionUnboundInPlasma (const FractionUnboundInPlasma_type& x);

          void
          FractionUnboundInPlasma (::std::unique_ptr< FractionUnboundInPlasma_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarData ReabsorptionRatio_type;

          typedef ::xsd::cxx::tree::traits< ReabsorptionRatio_type, char > ReabsorptionRatio_traits;

          const ReabsorptionRatio_type&
          ReabsorptionRatio () const;

          ReabsorptionRatio_type&
          ReabsorptionRatio ();

          void
          ReabsorptionRatio (const ReabsorptionRatio_type& x);

          void
          ReabsorptionRatio (::std::unique_ptr< ReabsorptionRatio_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerTimeData TransportMaximum_type;

          typedef ::xsd::cxx::tree::traits< TransportMaximum_type, char > TransportMaximum_traits;

          const TransportMaximum_type&
          TransportMaximum () const;

          TransportMaximum_type&
          TransportMaximum ();

          void
          TransportMaximum (const TransportMaximum_type& x);

          void
          TransportMaximum (::std::unique_ptr< TransportMaximum_type > p);



          Regulation ();

          Regulation (const ChargeInBlood_type&,
                      const FractionUnboundInPlasma_type&,
                      const ReabsorptionRatio_type&,
                      const TransportMaximum_type&);

          Regulation (const ChargeInBlood_type&,
                      ::std::unique_ptr< FractionUnboundInPlasma_type >,
                      ::std::unique_ptr< ReabsorptionRatio_type >,
                      ::std::unique_ptr< TransportMaximum_type >);

          Regulation (::std::unique_ptr< ChargeInBlood_type >,
                      ::std::unique_ptr< FractionUnboundInPlasma_type >,
                      ::std::unique_ptr< ReabsorptionRatio_type >,
                      ::std::unique_ptr< TransportMaximum_type >);

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

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

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

          Regulation&
          operator= (const Regulation& x);


          virtual 
          ~Regulation ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< ChargeInBlood_type > ChargeInBlood_;
          ::xsd::cxx::tree::one< FractionUnboundInPlasma_type > FractionUnboundInPlasma_;
          ::xsd::cxx::tree::one< ReabsorptionRatio_type > ReabsorptionRatio_;
          ::xsd::cxx::tree::one< TransportMaximum_type > TransportMaximum_;

          //@endcond
        };
      }
    }
  }
}

#include <iosfwd>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#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::SubstanceData >
        Substance (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::SubstanceData >
        Substance (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::SubstanceData >
        Substance (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::SubstanceData >
        Substance (::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::SubstanceData >
        Substance (::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::SubstanceData >
        Substance (::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::SubstanceData >
        Substance (::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::SubstanceData >
        Substance (::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::SubstanceData >
        Substance (::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::SubstanceData >
        Substance (::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::SubstanceData >
        Substance (::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::SubstanceData >
        Substance (::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::SubstanceData >
        Substance (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::SubstanceData >
        Substance (::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::SubstanceCompoundData >
        SubstanceCompound (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::SubstanceCompoundData >
        SubstanceCompound (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::SubstanceCompoundData >
        SubstanceCompound (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::SubstanceCompoundData >
        SubstanceCompound (::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::SubstanceCompoundData >
        SubstanceCompound (::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::SubstanceCompoundData >
        SubstanceCompound (::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::SubstanceCompoundData >
        SubstanceCompound (::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::SubstanceCompoundData >
        SubstanceCompound (::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::SubstanceCompoundData >
        SubstanceCompound (::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::SubstanceCompoundData >
        SubstanceCompound (::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::SubstanceCompoundData >
        SubstanceCompound (::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::SubstanceCompoundData >
        SubstanceCompound (::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::SubstanceCompoundData >
        SubstanceCompound (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::SubstanceCompoundData >
        SubstanceCompound (::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 enumSubstanceState&);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


        BIOGEARS_CDM_API
        void
        Substance (::std::ostream& os,
                   const ::mil::tatrc::physiology::datamodel::SubstanceData& 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
        Substance (::std::ostream& os,
                   const ::mil::tatrc::physiology::datamodel::SubstanceData& 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
        Substance (::std::ostream& os,
                   const ::mil::tatrc::physiology::datamodel::SubstanceData& 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
        Substance (::xercesc::XMLFormatTarget& ft,
                   const ::mil::tatrc::physiology::datamodel::SubstanceData& 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
        Substance (::xercesc::XMLFormatTarget& ft,
                   const ::mil::tatrc::physiology::datamodel::SubstanceData& 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
        Substance (::xercesc::XMLFormatTarget& ft,
                   const ::mil::tatrc::physiology::datamodel::SubstanceData& 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
        Substance (::xercesc::DOMDocument& d,
                   const ::mil::tatrc::physiology::datamodel::SubstanceData& x,
                   ::xml_schema::flags f = 0);

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


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


        BIOGEARS_CDM_API
        void
        SubstanceCompound (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& 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
        SubstanceCompound (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& 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
        SubstanceCompound (::std::ostream& os,
                           const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& 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
        SubstanceCompound (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& 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
        SubstanceCompound (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& 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
        SubstanceCompound (::xercesc::XMLFormatTarget& ft,
                           const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& 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
        SubstanceCompound (::xercesc::DOMDocument& d,
                           const ::mil::tatrc::physiology::datamodel::SubstanceCompoundData& x,
                           ::xml_schema::flags f = 0);

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


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

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

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

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

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

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

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

#include <xsd/cxx/post.hxx>

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

#endif // D__BIOGEARS_CORE_SHARE_XSD__CDM_SUBSTANCE_HXX