Compartment.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_COMPARTMENT_HXX
#define D__BIOGEARS_CORE_SHARE_XSD__CDM_COMPARTMENT_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 enumCompartmentType;
        class CompartmentData;
        class CompartmentLinkData;
        class CompartmentGraphData;
        class FluidCompartmentData;
        class FluidCompartmentLinkData;
        class FluidCompartmentGraphData;
        class GasCompartmentData;
        class GasCompartmentLinkData;
        class GasCompartmentGraphData;
        class LiquidCompartmentData;
        class LiquidCompartmentLinkData;
        class LiquidCompartmentGraphData;
        class TissueCompartmentData;
        class ThermalCompartmentData;
        class ThermalCompartmentLinkData;
        class ElectricalCompartmentData;
        class ElectricalCompartmentLinkData;
        class CompartmentManagerData;
      }
    }
  }
}


#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 "substancequantity.hxx"

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

          enum value
          {
            Electrical,
            Gas,
            Liquid,
            Thermal,
            Tissue
          };

          enumCompartmentType ();

          enumCompartmentType (value v);

          enumCompartmentType (const char* v);

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

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

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

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

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

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

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

          enumCompartmentType&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumCompartmentType_convert () const;

          public:
          static const char* const _xsd_enumCompartmentType_literals_[5];
          static const value _xsd_enumCompartmentType_indexes_[5];

          //@endcond
        };

        class BIOGEARS_CDM_API CompartmentData: 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 ::xml_schema::string Node_type;

          typedef ::xsd::cxx::tree::sequence< Node_type > Node_sequence;

          typedef Node_sequence::iterator Node_iterator;

          typedef Node_sequence::const_iterator Node_const_iterator;

          typedef ::xsd::cxx::tree::traits< Node_type, char > Node_traits;

          const Node_sequence&
          Node () const;

          Node_sequence&
          Node ();

          void
          Node (const Node_sequence& s);



          typedef ::xml_schema::string Child_type;

          typedef ::xsd::cxx::tree::sequence< Child_type > Child_sequence;

          typedef Child_sequence::iterator Child_iterator;

          typedef Child_sequence::const_iterator Child_const_iterator;

          typedef ::xsd::cxx::tree::traits< Child_type, char > Child_traits;

          const Child_sequence&
          Child () const;

          Child_sequence&
          Child ();

          void
          Child (const Child_sequence& s);



          CompartmentData ();

          CompartmentData (const Name_type&);

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

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

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

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

          CompartmentData&
          operator= (const CompartmentData& x);


          virtual 
          ~CompartmentData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Name_type > Name_;
          Node_sequence Node_;
          Child_sequence Child_;

          //@endcond
        };

        class BIOGEARS_CDM_API CompartmentLinkData: 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 ::xml_schema::string Path_type;

          typedef ::xsd::cxx::tree::optional< Path_type > Path_optional;

          typedef ::xsd::cxx::tree::traits< Path_type, char > Path_traits;

          const Path_optional&
          Path () const;

          Path_optional&
          Path ();

          void
          Path (const Path_type& x);

          void
          Path (const Path_optional& x);

          void
          Path (::std::unique_ptr< Path_type > p);



          typedef ::xml_schema::string SourceCompartment_type;

          typedef ::xsd::cxx::tree::traits< SourceCompartment_type, char > SourceCompartment_traits;

          const SourceCompartment_type&
          SourceCompartment () const;

          SourceCompartment_type&
          SourceCompartment ();

          void
          SourceCompartment (const SourceCompartment_type& x);

          void
          SourceCompartment (::std::unique_ptr< SourceCompartment_type > p);



          typedef ::xml_schema::string TargetCompartment_type;

          typedef ::xsd::cxx::tree::traits< TargetCompartment_type, char > TargetCompartment_traits;

          const TargetCompartment_type&
          TargetCompartment () const;

          TargetCompartment_type&
          TargetCompartment ();

          void
          TargetCompartment (const TargetCompartment_type& x);

          void
          TargetCompartment (::std::unique_ptr< TargetCompartment_type > p);



          CompartmentLinkData ();

          CompartmentLinkData (const Name_type&,
                               const SourceCompartment_type&,
                               const TargetCompartment_type&);

          CompartmentLinkData (::std::unique_ptr< Name_type >,
                               ::std::unique_ptr< SourceCompartment_type >,
                               ::std::unique_ptr< TargetCompartment_type >);

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

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

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

          CompartmentLinkData&
          operator= (const CompartmentLinkData& x);


          virtual 
          ~CompartmentLinkData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Name_type > Name_;
          Path_optional Path_;
          ::xsd::cxx::tree::one< SourceCompartment_type > SourceCompartment_;
          ::xsd::cxx::tree::one< TargetCompartment_type > TargetCompartment_;

          //@endcond
        };

        class BIOGEARS_CDM_API CompartmentGraphData: public ::xml_schema::type
        {
          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 ::xml_schema::string Compartment_type;

          typedef ::xsd::cxx::tree::sequence< Compartment_type > Compartment_sequence;

          typedef Compartment_sequence::iterator Compartment_iterator;

          typedef Compartment_sequence::const_iterator Compartment_const_iterator;

          typedef ::xsd::cxx::tree::traits< Compartment_type, char > Compartment_traits;

          const Compartment_sequence&
          Compartment () const;

          Compartment_sequence&
          Compartment ();

          void
          Compartment (const Compartment_sequence& s);



          typedef ::xml_schema::string Link_type;

          typedef ::xsd::cxx::tree::sequence< Link_type > Link_sequence;

          typedef Link_sequence::iterator Link_iterator;

          typedef Link_sequence::const_iterator Link_const_iterator;

          typedef ::xsd::cxx::tree::traits< Link_type, char > Link_traits;

          const Link_sequence&
          Link () const;

          Link_sequence&
          Link ();

          void
          Link (const Link_sequence& s);



          CompartmentGraphData ();

          CompartmentGraphData (const Name_type&);

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

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

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

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

          CompartmentGraphData&
          operator= (const CompartmentGraphData& x);


          virtual 
          ~CompartmentGraphData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Name_type > Name_;
          Compartment_sequence Compartment_;
          Link_sequence Link_;

          //@endcond
        };

        class BIOGEARS_CDM_API FluidCompartmentData: public ::mil::tatrc::physiology::datamodel::CompartmentData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< InFlow_type > InFlow_optional;

          typedef ::xsd::cxx::tree::traits< InFlow_type, char > InFlow_traits;

          const InFlow_optional&
          InFlow () const;

          InFlow_optional&
          InFlow ();

          void
          InFlow (const InFlow_type& x);

          void
          InFlow (const InFlow_optional& x);

          void
          InFlow (::std::unique_ptr< InFlow_type > p);



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

          typedef ::xsd::cxx::tree::optional< OutFlow_type > OutFlow_optional;

          typedef ::xsd::cxx::tree::traits< OutFlow_type, char > OutFlow_traits;

          const OutFlow_optional&
          OutFlow () const;

          OutFlow_optional&
          OutFlow ();

          void
          OutFlow (const OutFlow_type& x);

          void
          OutFlow (const OutFlow_optional& x);

          void
          OutFlow (::std::unique_ptr< OutFlow_type > p);



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

          typedef ::xsd::cxx::tree::optional< Pressure_type > Pressure_optional;

          typedef ::xsd::cxx::tree::traits< Pressure_type, char > Pressure_traits;

          const Pressure_optional&
          Pressure () const;

          Pressure_optional&
          Pressure ();

          void
          Pressure (const Pressure_type& x);

          void
          Pressure (const Pressure_optional& x);

          void
          Pressure (::std::unique_ptr< Pressure_type > p);



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

          typedef ::xsd::cxx::tree::optional< Volume_type > Volume_optional;

          typedef ::xsd::cxx::tree::traits< Volume_type, char > Volume_traits;

          const Volume_optional&
          Volume () const;

          Volume_optional&
          Volume ();

          void
          Volume (const Volume_type& x);

          void
          Volume (const Volume_optional& x);

          void
          Volume (::std::unique_ptr< Volume_type > p);



          FluidCompartmentData ();

          FluidCompartmentData (const Name_type&);

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

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

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

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

          FluidCompartmentData&
          operator= (const FluidCompartmentData& x);


          virtual 
          ~FluidCompartmentData ();

          // Implementation.
          //

          //@cond

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

          protected:
          InFlow_optional InFlow_;
          OutFlow_optional OutFlow_;
          Pressure_optional Pressure_;
          Volume_optional Volume_;

          //@endcond
        };

        class BIOGEARS_CDM_API FluidCompartmentLinkData: public ::mil::tatrc::physiology::datamodel::CompartmentLinkData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< Flow_type > Flow_optional;

          typedef ::xsd::cxx::tree::traits< Flow_type, char > Flow_traits;

          const Flow_optional&
          Flow () const;

          Flow_optional&
          Flow ();

          void
          Flow (const Flow_type& x);

          void
          Flow (const Flow_optional& x);

          void
          Flow (::std::unique_ptr< Flow_type > p);



          FluidCompartmentLinkData ();

          FluidCompartmentLinkData (const Name_type&,
                                    const SourceCompartment_type&,
                                    const TargetCompartment_type&);

          FluidCompartmentLinkData (::std::unique_ptr< Name_type >,
                                    ::std::unique_ptr< SourceCompartment_type >,
                                    ::std::unique_ptr< TargetCompartment_type >);

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

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

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

          FluidCompartmentLinkData&
          operator= (const FluidCompartmentLinkData& x);


          virtual 
          ~FluidCompartmentLinkData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Flow_optional Flow_;

          //@endcond
        };

        class BIOGEARS_CDM_API FluidCompartmentGraphData: public ::mil::tatrc::physiology::datamodel::CompartmentGraphData
        {
          public:

          FluidCompartmentGraphData ();

          FluidCompartmentGraphData (const Name_type&);

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

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

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

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


          virtual 
          ~FluidCompartmentGraphData ();
        };

        class BIOGEARS_CDM_API GasCompartmentData: public ::mil::tatrc::physiology::datamodel::FluidCompartmentData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::GasSubstanceQuantityData SubstanceQuantity_type;

          typedef ::xsd::cxx::tree::sequence< SubstanceQuantity_type > SubstanceQuantity_sequence;

          typedef SubstanceQuantity_sequence::iterator SubstanceQuantity_iterator;

          typedef SubstanceQuantity_sequence::const_iterator SubstanceQuantity_const_iterator;

          typedef ::xsd::cxx::tree::traits< SubstanceQuantity_type, char > SubstanceQuantity_traits;

          const SubstanceQuantity_sequence&
          SubstanceQuantity () const;

          SubstanceQuantity_sequence&
          SubstanceQuantity ();

          void
          SubstanceQuantity (const SubstanceQuantity_sequence& s);



          GasCompartmentData ();

          GasCompartmentData (const Name_type&);

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

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

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

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

          GasCompartmentData&
          operator= (const GasCompartmentData& x);


          virtual 
          ~GasCompartmentData ();

          // Implementation.
          //

          //@cond

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

          protected:
          SubstanceQuantity_sequence SubstanceQuantity_;

          //@endcond
        };

        class BIOGEARS_CDM_API GasCompartmentLinkData: public ::mil::tatrc::physiology::datamodel::FluidCompartmentLinkData
        {
          public:

          GasCompartmentLinkData ();

          GasCompartmentLinkData (const Name_type&,
                                  const SourceCompartment_type&,
                                  const TargetCompartment_type&);

          GasCompartmentLinkData (::std::unique_ptr< Name_type >,
                                  ::std::unique_ptr< SourceCompartment_type >,
                                  ::std::unique_ptr< TargetCompartment_type >);

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

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

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


          virtual 
          ~GasCompartmentLinkData ();
        };

        class BIOGEARS_CDM_API GasCompartmentGraphData: public ::mil::tatrc::physiology::datamodel::FluidCompartmentGraphData
        {
          public:

          GasCompartmentGraphData ();

          GasCompartmentGraphData (const Name_type&);

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

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

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

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


          virtual 
          ~GasCompartmentGraphData ();
        };

        class BIOGEARS_CDM_API LiquidCompartmentData: public ::mil::tatrc::physiology::datamodel::FluidCompartmentData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< pH_type > pH_optional;

          typedef ::xsd::cxx::tree::traits< pH_type, char > pH_traits;

          const pH_optional&
          pH () const;

          pH_optional&
          pH ();

          void
          pH (const pH_type& x);

          void
          pH (const pH_optional& x);

          void
          pH (::std::unique_ptr< pH_type > p);



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

          typedef ::xsd::cxx::tree::optional< WaterVolumeFraction_type > WaterVolumeFraction_optional;

          typedef ::xsd::cxx::tree::traits< WaterVolumeFraction_type, char > WaterVolumeFraction_traits;

          const WaterVolumeFraction_optional&
          WaterVolumeFraction () const;

          WaterVolumeFraction_optional&
          WaterVolumeFraction ();

          void
          WaterVolumeFraction (const WaterVolumeFraction_type& x);

          void
          WaterVolumeFraction (const WaterVolumeFraction_optional& x);

          void
          WaterVolumeFraction (::std::unique_ptr< WaterVolumeFraction_type > p);



          typedef ::mil::tatrc::physiology::datamodel::LiquidSubstanceQuantityData SubstanceQuantity_type;

          typedef ::xsd::cxx::tree::sequence< SubstanceQuantity_type > SubstanceQuantity_sequence;

          typedef SubstanceQuantity_sequence::iterator SubstanceQuantity_iterator;

          typedef SubstanceQuantity_sequence::const_iterator SubstanceQuantity_const_iterator;

          typedef ::xsd::cxx::tree::traits< SubstanceQuantity_type, char > SubstanceQuantity_traits;

          const SubstanceQuantity_sequence&
          SubstanceQuantity () const;

          SubstanceQuantity_sequence&
          SubstanceQuantity ();

          void
          SubstanceQuantity (const SubstanceQuantity_sequence& s);



          LiquidCompartmentData ();

          LiquidCompartmentData (const Name_type&);

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

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

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

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

          LiquidCompartmentData&
          operator= (const LiquidCompartmentData& x);


          virtual 
          ~LiquidCompartmentData ();

          // Implementation.
          //

          //@cond

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

          protected:
          pH_optional pH_;
          WaterVolumeFraction_optional WaterVolumeFraction_;
          SubstanceQuantity_sequence SubstanceQuantity_;

          //@endcond
        };

        class BIOGEARS_CDM_API LiquidCompartmentLinkData: public ::mil::tatrc::physiology::datamodel::FluidCompartmentLinkData
        {
          public:

          LiquidCompartmentLinkData ();

          LiquidCompartmentLinkData (const Name_type&,
                                     const SourceCompartment_type&,
                                     const TargetCompartment_type&);

          LiquidCompartmentLinkData (::std::unique_ptr< Name_type >,
                                     ::std::unique_ptr< SourceCompartment_type >,
                                     ::std::unique_ptr< TargetCompartment_type >);

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

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

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


          virtual 
          ~LiquidCompartmentLinkData ();
        };

        class BIOGEARS_CDM_API LiquidCompartmentGraphData: public ::mil::tatrc::physiology::datamodel::FluidCompartmentGraphData
        {
          public:

          LiquidCompartmentGraphData ();

          LiquidCompartmentGraphData (const Name_type&);

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

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

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

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


          virtual 
          ~LiquidCompartmentGraphData ();
        };

        class BIOGEARS_CDM_API TissueCompartmentData: public ::mil::tatrc::physiology::datamodel::CompartmentData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarMassPerMassData AcidicPhospohlipidConcentration_type;

          typedef ::xsd::cxx::tree::optional< AcidicPhospohlipidConcentration_type > AcidicPhospohlipidConcentration_optional;

          typedef ::xsd::cxx::tree::traits< AcidicPhospohlipidConcentration_type, char > AcidicPhospohlipidConcentration_traits;

          const AcidicPhospohlipidConcentration_optional&
          AcidicPhospohlipidConcentration () const;

          AcidicPhospohlipidConcentration_optional&
          AcidicPhospohlipidConcentration ();

          void
          AcidicPhospohlipidConcentration (const AcidicPhospohlipidConcentration_type& x);

          void
          AcidicPhospohlipidConcentration (const AcidicPhospohlipidConcentration_optional& x);

          void
          AcidicPhospohlipidConcentration (::std::unique_ptr< AcidicPhospohlipidConcentration_type > p);



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

          typedef ::xsd::cxx::tree::optional< MatrixVolume_type > MatrixVolume_optional;

          typedef ::xsd::cxx::tree::traits< MatrixVolume_type, char > MatrixVolume_traits;

          const MatrixVolume_optional&
          MatrixVolume () const;

          MatrixVolume_optional&
          MatrixVolume ();

          void
          MatrixVolume (const MatrixVolume_type& x);

          void
          MatrixVolume (const MatrixVolume_optional& x);

          void
          MatrixVolume (::std::unique_ptr< MatrixVolume_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricPotentialData MembranePotential_type;

          typedef ::xsd::cxx::tree::optional< MembranePotential_type > MembranePotential_optional;

          typedef ::xsd::cxx::tree::traits< MembranePotential_type, char > MembranePotential_traits;

          const MembranePotential_optional&
          MembranePotential () const;

          MembranePotential_optional&
          MembranePotential ();

          void
          MembranePotential (const MembranePotential_type& x);

          void
          MembranePotential (const MembranePotential_optional& x);

          void
          MembranePotential (::std::unique_ptr< MembranePotential_type > p);



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

          typedef ::xsd::cxx::tree::optional< NeutralLipidsVolumeFraction_type > NeutralLipidsVolumeFraction_optional;

          typedef ::xsd::cxx::tree::traits< NeutralLipidsVolumeFraction_type, char > NeutralLipidsVolumeFraction_traits;

          const NeutralLipidsVolumeFraction_optional&
          NeutralLipidsVolumeFraction () const;

          NeutralLipidsVolumeFraction_optional&
          NeutralLipidsVolumeFraction ();

          void
          NeutralLipidsVolumeFraction (const NeutralLipidsVolumeFraction_type& x);

          void
          NeutralLipidsVolumeFraction (const NeutralLipidsVolumeFraction_optional& x);

          void
          NeutralLipidsVolumeFraction (::std::unique_ptr< NeutralLipidsVolumeFraction_type > p);



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

          typedef ::xsd::cxx::tree::optional< NeutralPhospholipidsVolumeFraction_type > NeutralPhospholipidsVolumeFraction_optional;

          typedef ::xsd::cxx::tree::traits< NeutralPhospholipidsVolumeFraction_type, char > NeutralPhospholipidsVolumeFraction_traits;

          const NeutralPhospholipidsVolumeFraction_optional&
          NeutralPhospholipidsVolumeFraction () const;

          NeutralPhospholipidsVolumeFraction_optional&
          NeutralPhospholipidsVolumeFraction ();

          void
          NeutralPhospholipidsVolumeFraction (const NeutralPhospholipidsVolumeFraction_type& x);

          void
          NeutralPhospholipidsVolumeFraction (const NeutralPhospholipidsVolumeFraction_optional& x);

          void
          NeutralPhospholipidsVolumeFraction (::std::unique_ptr< NeutralPhospholipidsVolumeFraction_type > p);



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

          typedef ::xsd::cxx::tree::optional< ReflectionCoefficient_type > ReflectionCoefficient_optional;

          typedef ::xsd::cxx::tree::traits< ReflectionCoefficient_type, char > ReflectionCoefficient_traits;

          const ReflectionCoefficient_optional&
          ReflectionCoefficient () const;

          ReflectionCoefficient_optional&
          ReflectionCoefficient ();

          void
          ReflectionCoefficient (const ReflectionCoefficient_type& x);

          void
          ReflectionCoefficient (const ReflectionCoefficient_optional& x);

          void
          ReflectionCoefficient (::std::unique_ptr< ReflectionCoefficient_type > p);



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

          typedef ::xsd::cxx::tree::optional< TissueToPlasmaAlbuminRatio_type > TissueToPlasmaAlbuminRatio_optional;

          typedef ::xsd::cxx::tree::traits< TissueToPlasmaAlbuminRatio_type, char > TissueToPlasmaAlbuminRatio_traits;

          const TissueToPlasmaAlbuminRatio_optional&
          TissueToPlasmaAlbuminRatio () const;

          TissueToPlasmaAlbuminRatio_optional&
          TissueToPlasmaAlbuminRatio ();

          void
          TissueToPlasmaAlbuminRatio (const TissueToPlasmaAlbuminRatio_type& x);

          void
          TissueToPlasmaAlbuminRatio (const TissueToPlasmaAlbuminRatio_optional& x);

          void
          TissueToPlasmaAlbuminRatio (::std::unique_ptr< TissueToPlasmaAlbuminRatio_type > p);



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

          typedef ::xsd::cxx::tree::optional< TissueToPlasmaAlphaAcidGlycoproteinRatio_type > TissueToPlasmaAlphaAcidGlycoproteinRatio_optional;

          typedef ::xsd::cxx::tree::traits< TissueToPlasmaAlphaAcidGlycoproteinRatio_type, char > TissueToPlasmaAlphaAcidGlycoproteinRatio_traits;

          const TissueToPlasmaAlphaAcidGlycoproteinRatio_optional&
          TissueToPlasmaAlphaAcidGlycoproteinRatio () const;

          TissueToPlasmaAlphaAcidGlycoproteinRatio_optional&
          TissueToPlasmaAlphaAcidGlycoproteinRatio ();

          void
          TissueToPlasmaAlphaAcidGlycoproteinRatio (const TissueToPlasmaAlphaAcidGlycoproteinRatio_type& x);

          void
          TissueToPlasmaAlphaAcidGlycoproteinRatio (const TissueToPlasmaAlphaAcidGlycoproteinRatio_optional& x);

          void
          TissueToPlasmaAlphaAcidGlycoproteinRatio (::std::unique_ptr< TissueToPlasmaAlphaAcidGlycoproteinRatio_type > p);



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

          typedef ::xsd::cxx::tree::optional< TissueToPlasmaLipoproteinRatio_type > TissueToPlasmaLipoproteinRatio_optional;

          typedef ::xsd::cxx::tree::traits< TissueToPlasmaLipoproteinRatio_type, char > TissueToPlasmaLipoproteinRatio_traits;

          const TissueToPlasmaLipoproteinRatio_optional&
          TissueToPlasmaLipoproteinRatio () const;

          TissueToPlasmaLipoproteinRatio_optional&
          TissueToPlasmaLipoproteinRatio ();

          void
          TissueToPlasmaLipoproteinRatio (const TissueToPlasmaLipoproteinRatio_type& x);

          void
          TissueToPlasmaLipoproteinRatio (const TissueToPlasmaLipoproteinRatio_optional& x);

          void
          TissueToPlasmaLipoproteinRatio (::std::unique_ptr< TissueToPlasmaLipoproteinRatio_type > p);



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

          typedef ::xsd::cxx::tree::optional< TotalMass_type > TotalMass_optional;

          typedef ::xsd::cxx::tree::traits< TotalMass_type, char > TotalMass_traits;

          const TotalMass_optional&
          TotalMass () const;

          TotalMass_optional&
          TotalMass ();

          void
          TotalMass (const TotalMass_type& x);

          void
          TotalMass (const TotalMass_optional& x);

          void
          TotalMass (::std::unique_ptr< TotalMass_type > p);



          TissueCompartmentData ();

          TissueCompartmentData (const Name_type&);

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

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

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

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

          TissueCompartmentData&
          operator= (const TissueCompartmentData& x);


          virtual 
          ~TissueCompartmentData ();

          // Implementation.
          //

          //@cond

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

          protected:
          AcidicPhospohlipidConcentration_optional AcidicPhospohlipidConcentration_;
          MatrixVolume_optional MatrixVolume_;
          MembranePotential_optional MembranePotential_;
          NeutralLipidsVolumeFraction_optional NeutralLipidsVolumeFraction_;
          NeutralPhospholipidsVolumeFraction_optional NeutralPhospholipidsVolumeFraction_;
          ReflectionCoefficient_optional ReflectionCoefficient_;
          TissueToPlasmaAlbuminRatio_optional TissueToPlasmaAlbuminRatio_;
          TissueToPlasmaAlphaAcidGlycoproteinRatio_optional TissueToPlasmaAlphaAcidGlycoproteinRatio_;
          TissueToPlasmaLipoproteinRatio_optional TissueToPlasmaLipoproteinRatio_;
          TotalMass_optional TotalMass_;

          //@endcond
        };

        class BIOGEARS_CDM_API ThermalCompartmentData: public ::mil::tatrc::physiology::datamodel::CompartmentData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< HeatTransferRateIn_type > HeatTransferRateIn_optional;

          typedef ::xsd::cxx::tree::traits< HeatTransferRateIn_type, char > HeatTransferRateIn_traits;

          const HeatTransferRateIn_optional&
          HeatTransferRateIn () const;

          HeatTransferRateIn_optional&
          HeatTransferRateIn ();

          void
          HeatTransferRateIn (const HeatTransferRateIn_type& x);

          void
          HeatTransferRateIn (const HeatTransferRateIn_optional& x);

          void
          HeatTransferRateIn (::std::unique_ptr< HeatTransferRateIn_type > p);



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

          typedef ::xsd::cxx::tree::optional< HeatTransferRateOut_type > HeatTransferRateOut_optional;

          typedef ::xsd::cxx::tree::traits< HeatTransferRateOut_type, char > HeatTransferRateOut_traits;

          const HeatTransferRateOut_optional&
          HeatTransferRateOut () const;

          HeatTransferRateOut_optional&
          HeatTransferRateOut ();

          void
          HeatTransferRateOut (const HeatTransferRateOut_type& x);

          void
          HeatTransferRateOut (const HeatTransferRateOut_optional& x);

          void
          HeatTransferRateOut (::std::unique_ptr< HeatTransferRateOut_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarTemperatureData Temperature_type;

          typedef ::xsd::cxx::tree::optional< Temperature_type > Temperature_optional;

          typedef ::xsd::cxx::tree::traits< Temperature_type, char > Temperature_traits;

          const Temperature_optional&
          Temperature () const;

          Temperature_optional&
          Temperature ();

          void
          Temperature (const Temperature_type& x);

          void
          Temperature (const Temperature_optional& x);

          void
          Temperature (::std::unique_ptr< Temperature_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarEnergyData Heat_type;

          typedef ::xsd::cxx::tree::optional< Heat_type > Heat_optional;

          typedef ::xsd::cxx::tree::traits< Heat_type, char > Heat_traits;

          const Heat_optional&
          Heat () const;

          Heat_optional&
          Heat ();

          void
          Heat (const Heat_type& x);

          void
          Heat (const Heat_optional& x);

          void
          Heat (::std::unique_ptr< Heat_type > p);



          ThermalCompartmentData ();

          ThermalCompartmentData (const Name_type&);

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

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

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

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

          ThermalCompartmentData&
          operator= (const ThermalCompartmentData& x);


          virtual 
          ~ThermalCompartmentData ();

          // Implementation.
          //

          //@cond

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

          protected:
          HeatTransferRateIn_optional HeatTransferRateIn_;
          HeatTransferRateOut_optional HeatTransferRateOut_;
          Temperature_optional Temperature_;
          Heat_optional Heat_;

          //@endcond
        };

        class BIOGEARS_CDM_API ThermalCompartmentLinkData: public ::mil::tatrc::physiology::datamodel::CompartmentLinkData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< HeatTransferRate_type > HeatTransferRate_optional;

          typedef ::xsd::cxx::tree::traits< HeatTransferRate_type, char > HeatTransferRate_traits;

          const HeatTransferRate_optional&
          HeatTransferRate () const;

          HeatTransferRate_optional&
          HeatTransferRate ();

          void
          HeatTransferRate (const HeatTransferRate_type& x);

          void
          HeatTransferRate (const HeatTransferRate_optional& x);

          void
          HeatTransferRate (::std::unique_ptr< HeatTransferRate_type > p);



          ThermalCompartmentLinkData ();

          ThermalCompartmentLinkData (const Name_type&,
                                      const SourceCompartment_type&,
                                      const TargetCompartment_type&);

          ThermalCompartmentLinkData (::std::unique_ptr< Name_type >,
                                      ::std::unique_ptr< SourceCompartment_type >,
                                      ::std::unique_ptr< TargetCompartment_type >);

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

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

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

          ThermalCompartmentLinkData&
          operator= (const ThermalCompartmentLinkData& x);


          virtual 
          ~ThermalCompartmentLinkData ();

          // Implementation.
          //

          //@cond

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

          protected:
          HeatTransferRate_optional HeatTransferRate_;

          //@endcond
        };

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

          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricCurrentData CurrentIn_type;

          typedef ::xsd::cxx::tree::optional< CurrentIn_type > CurrentIn_optional;

          typedef ::xsd::cxx::tree::traits< CurrentIn_type, char > CurrentIn_traits;

          const CurrentIn_optional&
          CurrentIn () const;

          CurrentIn_optional&
          CurrentIn ();

          void
          CurrentIn (const CurrentIn_type& x);

          void
          CurrentIn (const CurrentIn_optional& x);

          void
          CurrentIn (::std::unique_ptr< CurrentIn_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricCurrentData CurrentOut_type;

          typedef ::xsd::cxx::tree::optional< CurrentOut_type > CurrentOut_optional;

          typedef ::xsd::cxx::tree::traits< CurrentOut_type, char > CurrentOut_traits;

          const CurrentOut_optional&
          CurrentOut () const;

          CurrentOut_optional&
          CurrentOut ();

          void
          CurrentOut (const CurrentOut_type& x);

          void
          CurrentOut (const CurrentOut_optional& x);

          void
          CurrentOut (::std::unique_ptr< CurrentOut_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricPotentialData Voltage_type;

          typedef ::xsd::cxx::tree::optional< Voltage_type > Voltage_optional;

          typedef ::xsd::cxx::tree::traits< Voltage_type, char > Voltage_traits;

          const Voltage_optional&
          Voltage () const;

          Voltage_optional&
          Voltage ();

          void
          Voltage (const Voltage_type& x);

          void
          Voltage (const Voltage_optional& x);

          void
          Voltage (::std::unique_ptr< Voltage_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricChargeData Charge_type;

          typedef ::xsd::cxx::tree::optional< Charge_type > Charge_optional;

          typedef ::xsd::cxx::tree::traits< Charge_type, char > Charge_traits;

          const Charge_optional&
          Charge () const;

          Charge_optional&
          Charge ();

          void
          Charge (const Charge_type& x);

          void
          Charge (const Charge_optional& x);

          void
          Charge (::std::unique_ptr< Charge_type > p);



          ElectricalCompartmentData ();

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

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

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

          ElectricalCompartmentData&
          operator= (const ElectricalCompartmentData& x);


          virtual 
          ~ElectricalCompartmentData ();

          // Implementation.
          //

          //@cond

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

          protected:
          CurrentIn_optional CurrentIn_;
          CurrentOut_optional CurrentOut_;
          Voltage_optional Voltage_;
          Charge_optional Charge_;

          //@endcond
        };

        class BIOGEARS_CDM_API ElectricalCompartmentLinkData: public ::mil::tatrc::physiology::datamodel::CompartmentLinkData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< Current_type > Current_optional;

          typedef ::xsd::cxx::tree::traits< Current_type, char > Current_traits;

          const Current_optional&
          Current () const;

          Current_optional&
          Current ();

          void
          Current (const Current_type& x);

          void
          Current (const Current_optional& x);

          void
          Current (::std::unique_ptr< Current_type > p);



          ElectricalCompartmentLinkData ();

          ElectricalCompartmentLinkData (const Name_type&,
                                         const SourceCompartment_type&,
                                         const TargetCompartment_type&);

          ElectricalCompartmentLinkData (::std::unique_ptr< Name_type >,
                                         ::std::unique_ptr< SourceCompartment_type >,
                                         ::std::unique_ptr< TargetCompartment_type >);

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

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

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

          ElectricalCompartmentLinkData&
          operator= (const ElectricalCompartmentLinkData& x);


          virtual 
          ~ElectricalCompartmentLinkData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Current_optional Current_;

          //@endcond
        };

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

          typedef ::mil::tatrc::physiology::datamodel::ElectricalCompartmentData ElectricalCompartment_type;

          typedef ::xsd::cxx::tree::sequence< ElectricalCompartment_type > ElectricalCompartment_sequence;

          typedef ElectricalCompartment_sequence::iterator ElectricalCompartment_iterator;

          typedef ElectricalCompartment_sequence::const_iterator ElectricalCompartment_const_iterator;

          typedef ::xsd::cxx::tree::traits< ElectricalCompartment_type, char > ElectricalCompartment_traits;

          const ElectricalCompartment_sequence&
          ElectricalCompartment () const;

          ElectricalCompartment_sequence&
          ElectricalCompartment ();

          void
          ElectricalCompartment (const ElectricalCompartment_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::ElectricalCompartmentLinkData ElectricalLink_type;

          typedef ::xsd::cxx::tree::sequence< ElectricalLink_type > ElectricalLink_sequence;

          typedef ElectricalLink_sequence::iterator ElectricalLink_iterator;

          typedef ElectricalLink_sequence::const_iterator ElectricalLink_const_iterator;

          typedef ::xsd::cxx::tree::traits< ElectricalLink_type, char > ElectricalLink_traits;

          const ElectricalLink_sequence&
          ElectricalLink () const;

          ElectricalLink_sequence&
          ElectricalLink ();

          void
          ElectricalLink (const ElectricalLink_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::LiquidCompartmentData LiquidCompartment_type;

          typedef ::xsd::cxx::tree::sequence< LiquidCompartment_type > LiquidCompartment_sequence;

          typedef LiquidCompartment_sequence::iterator LiquidCompartment_iterator;

          typedef LiquidCompartment_sequence::const_iterator LiquidCompartment_const_iterator;

          typedef ::xsd::cxx::tree::traits< LiquidCompartment_type, char > LiquidCompartment_traits;

          const LiquidCompartment_sequence&
          LiquidCompartment () const;

          LiquidCompartment_sequence&
          LiquidCompartment ();

          void
          LiquidCompartment (const LiquidCompartment_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::LiquidCompartmentLinkData LiquidLink_type;

          typedef ::xsd::cxx::tree::sequence< LiquidLink_type > LiquidLink_sequence;

          typedef LiquidLink_sequence::iterator LiquidLink_iterator;

          typedef LiquidLink_sequence::const_iterator LiquidLink_const_iterator;

          typedef ::xsd::cxx::tree::traits< LiquidLink_type, char > LiquidLink_traits;

          const LiquidLink_sequence&
          LiquidLink () const;

          LiquidLink_sequence&
          LiquidLink ();

          void
          LiquidLink (const LiquidLink_sequence& s);



          typedef ::xml_schema::string LiquidSubstance_type;

          typedef ::xsd::cxx::tree::sequence< LiquidSubstance_type > LiquidSubstance_sequence;

          typedef LiquidSubstance_sequence::iterator LiquidSubstance_iterator;

          typedef LiquidSubstance_sequence::const_iterator LiquidSubstance_const_iterator;

          typedef ::xsd::cxx::tree::traits< LiquidSubstance_type, char > LiquidSubstance_traits;

          const LiquidSubstance_sequence&
          LiquidSubstance () const;

          LiquidSubstance_sequence&
          LiquidSubstance ();

          void
          LiquidSubstance (const LiquidSubstance_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::LiquidCompartmentGraphData LiquidGraph_type;

          typedef ::xsd::cxx::tree::sequence< LiquidGraph_type > LiquidGraph_sequence;

          typedef LiquidGraph_sequence::iterator LiquidGraph_iterator;

          typedef LiquidGraph_sequence::const_iterator LiquidGraph_const_iterator;

          typedef ::xsd::cxx::tree::traits< LiquidGraph_type, char > LiquidGraph_traits;

          const LiquidGraph_sequence&
          LiquidGraph () const;

          LiquidGraph_sequence&
          LiquidGraph ();

          void
          LiquidGraph (const LiquidGraph_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::GasCompartmentData GasCompartment_type;

          typedef ::xsd::cxx::tree::sequence< GasCompartment_type > GasCompartment_sequence;

          typedef GasCompartment_sequence::iterator GasCompartment_iterator;

          typedef GasCompartment_sequence::const_iterator GasCompartment_const_iterator;

          typedef ::xsd::cxx::tree::traits< GasCompartment_type, char > GasCompartment_traits;

          const GasCompartment_sequence&
          GasCompartment () const;

          GasCompartment_sequence&
          GasCompartment ();

          void
          GasCompartment (const GasCompartment_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::GasCompartmentLinkData GasLink_type;

          typedef ::xsd::cxx::tree::sequence< GasLink_type > GasLink_sequence;

          typedef GasLink_sequence::iterator GasLink_iterator;

          typedef GasLink_sequence::const_iterator GasLink_const_iterator;

          typedef ::xsd::cxx::tree::traits< GasLink_type, char > GasLink_traits;

          const GasLink_sequence&
          GasLink () const;

          GasLink_sequence&
          GasLink ();

          void
          GasLink (const GasLink_sequence& s);



          typedef ::xml_schema::string GasSubstance_type;

          typedef ::xsd::cxx::tree::sequence< GasSubstance_type > GasSubstance_sequence;

          typedef GasSubstance_sequence::iterator GasSubstance_iterator;

          typedef GasSubstance_sequence::const_iterator GasSubstance_const_iterator;

          typedef ::xsd::cxx::tree::traits< GasSubstance_type, char > GasSubstance_traits;

          const GasSubstance_sequence&
          GasSubstance () const;

          GasSubstance_sequence&
          GasSubstance ();

          void
          GasSubstance (const GasSubstance_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::GasCompartmentGraphData GasGraph_type;

          typedef ::xsd::cxx::tree::sequence< GasGraph_type > GasGraph_sequence;

          typedef GasGraph_sequence::iterator GasGraph_iterator;

          typedef GasGraph_sequence::const_iterator GasGraph_const_iterator;

          typedef ::xsd::cxx::tree::traits< GasGraph_type, char > GasGraph_traits;

          const GasGraph_sequence&
          GasGraph () const;

          GasGraph_sequence&
          GasGraph ();

          void
          GasGraph (const GasGraph_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::ThermalCompartmentData ThermalCompartment_type;

          typedef ::xsd::cxx::tree::sequence< ThermalCompartment_type > ThermalCompartment_sequence;

          typedef ThermalCompartment_sequence::iterator ThermalCompartment_iterator;

          typedef ThermalCompartment_sequence::const_iterator ThermalCompartment_const_iterator;

          typedef ::xsd::cxx::tree::traits< ThermalCompartment_type, char > ThermalCompartment_traits;

          const ThermalCompartment_sequence&
          ThermalCompartment () const;

          ThermalCompartment_sequence&
          ThermalCompartment ();

          void
          ThermalCompartment (const ThermalCompartment_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::ThermalCompartmentLinkData ThermalLink_type;

          typedef ::xsd::cxx::tree::sequence< ThermalLink_type > ThermalLink_sequence;

          typedef ThermalLink_sequence::iterator ThermalLink_iterator;

          typedef ThermalLink_sequence::const_iterator ThermalLink_const_iterator;

          typedef ::xsd::cxx::tree::traits< ThermalLink_type, char > ThermalLink_traits;

          const ThermalLink_sequence&
          ThermalLink () const;

          ThermalLink_sequence&
          ThermalLink ();

          void
          ThermalLink (const ThermalLink_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::TissueCompartmentData TissueCompartment_type;

          typedef ::xsd::cxx::tree::sequence< TissueCompartment_type > TissueCompartment_sequence;

          typedef TissueCompartment_sequence::iterator TissueCompartment_iterator;

          typedef TissueCompartment_sequence::const_iterator TissueCompartment_const_iterator;

          typedef ::xsd::cxx::tree::traits< TissueCompartment_type, char > TissueCompartment_traits;

          const TissueCompartment_sequence&
          TissueCompartment () const;

          TissueCompartment_sequence&
          TissueCompartment ();

          void
          TissueCompartment (const TissueCompartment_sequence& s);



          typedef ::xml_schema::string TissueSubstance_type;

          typedef ::xsd::cxx::tree::sequence< TissueSubstance_type > TissueSubstance_sequence;

          typedef TissueSubstance_sequence::iterator TissueSubstance_iterator;

          typedef TissueSubstance_sequence::const_iterator TissueSubstance_const_iterator;

          typedef ::xsd::cxx::tree::traits< TissueSubstance_type, char > TissueSubstance_traits;

          const TissueSubstance_sequence&
          TissueSubstance () const;

          TissueSubstance_sequence&
          TissueSubstance ();

          void
          TissueSubstance (const TissueSubstance_sequence& s);



          CompartmentManagerData ();

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

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

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

          CompartmentManagerData&
          operator= (const CompartmentManagerData& x);


          virtual 
          ~CompartmentManagerData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ElectricalCompartment_sequence ElectricalCompartment_;
          ElectricalLink_sequence ElectricalLink_;
          LiquidCompartment_sequence LiquidCompartment_;
          LiquidLink_sequence LiquidLink_;
          LiquidSubstance_sequence LiquidSubstance_;
          LiquidGraph_sequence LiquidGraph_;
          GasCompartment_sequence GasCompartment_;
          GasLink_sequence GasLink_;
          GasSubstance_sequence GasSubstance_;
          GasGraph_sequence GasGraph_;
          ThermalCompartment_sequence ThermalCompartment_;
          ThermalLink_sequence ThermalLink_;
          TissueCompartment_sequence TissueCompartment_;
          TissueSubstance_sequence TissueSubstance_;

          //@endcond
        };
      }
    }
  }
}

#include <iosfwd>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#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::CompartmentManagerData >
        CompartmentManager (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::CompartmentManagerData >
        CompartmentManager (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::CompartmentManagerData >
        CompartmentManager (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::CompartmentManagerData >
        CompartmentManager (::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::CompartmentManagerData >
        CompartmentManager (::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::CompartmentManagerData >
        CompartmentManager (::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::CompartmentManagerData >
        CompartmentManager (::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::CompartmentManagerData >
        CompartmentManager (::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::CompartmentManagerData >
        CompartmentManager (::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::CompartmentManagerData >
        CompartmentManager (::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::CompartmentManagerData >
        CompartmentManager (::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::CompartmentManagerData >
        CompartmentManager (::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::CompartmentManagerData >
        CompartmentManager (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::CompartmentManagerData >
        CompartmentManager (::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 enumCompartmentType&);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

      }
    }
  }
}

#include <xsd/cxx/post.hxx>

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

#endif // D__BIOGEARS_CORE_SHARE_XSD__CDM_COMPARTMENT_HXX