Circuit.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_CIRCUIT_HXX
#define D__BIOGEARS_CORE_SHARE_XSD__CDM_CIRCUIT_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 enumCircuitType;
        class enumResistancePathType;
        class CircuitData;
        class CircuitNodeData;
        class CircuitPathData;
        class ElectricalCircuitData;
        class ElectricalCircuitNodeData;
        class ElectricalCircuitPathData;
        class FluidCircuitData;
        class FluidCircuitNodeData;
        class FluidCircuitPathData;
        class ThermalCircuitData;
        class ThermalCircuitNodeData;
        class ThermalCircuitPathData;
        class CircuitManagerData;
      }
    }
  }
}


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

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

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

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

#include "properties.hxx"

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

          enum value
          {
            Electrical,
            Fluid,
            Thermal
          };

          enumCircuitType ();

          enumCircuitType (value v);

          enumCircuitType (const char* v);

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

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

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

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

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

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

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

          enumCircuitType&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumCircuitType_convert () const;

          public:
          static const char* const _xsd_enumCircuitType_literals_[3];
          static const value _xsd_enumCircuitType_indexes_[3];

          //@endcond
        };

        class BIOGEARS_CDM_API enumResistancePathType: public ::xml_schema::string
        {
          public:

          enum value
          {
            Cerebral,
            Extrasplanchnic,
            Muscle,
            Splanchnic,
            Myocardium
          };

          enumResistancePathType ();

          enumResistancePathType (value v);

          enumResistancePathType (const char* v);

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

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

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

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

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

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

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

          enumResistancePathType&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumResistancePathType_convert () const;

          public:
          static const char* const _xsd_enumResistancePathType_literals_[5];
          static const value _xsd_enumResistancePathType_indexes_[5];

          //@endcond
        };

        class BIOGEARS_CDM_API CircuitData: 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 ReferenceNode_type;

          typedef ::xsd::cxx::tree::sequence< ReferenceNode_type > ReferenceNode_sequence;

          typedef ReferenceNode_sequence::iterator ReferenceNode_iterator;

          typedef ReferenceNode_sequence::const_iterator ReferenceNode_const_iterator;

          typedef ::xsd::cxx::tree::traits< ReferenceNode_type, char > ReferenceNode_traits;

          const ReferenceNode_sequence&
          ReferenceNode () const;

          ReferenceNode_sequence&
          ReferenceNode ();

          void
          ReferenceNode (const ReferenceNode_sequence& s);



          CircuitData ();

          CircuitData (const Name_type&);

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

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

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

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

          CircuitData&
          operator= (const CircuitData& x);


          virtual 
          ~CircuitData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Name_type > Name_;
          ReferenceNode_sequence ReferenceNode_;

          //@endcond
        };

        class BIOGEARS_CDM_API CircuitNodeData: 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);



          CircuitNodeData ();

          CircuitNodeData (const Name_type&);

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

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

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

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

          CircuitNodeData&
          operator= (const CircuitNodeData& x);


          virtual 
          ~CircuitNodeData ();

          // Implementation.
          //

          //@cond

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

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

          //@endcond
        };

        class BIOGEARS_CDM_API CircuitPathData: 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 SourceNode_type;

          typedef ::xsd::cxx::tree::traits< SourceNode_type, char > SourceNode_traits;

          const SourceNode_type&
          SourceNode () const;

          SourceNode_type&
          SourceNode ();

          void
          SourceNode (const SourceNode_type& x);

          void
          SourceNode (::std::unique_ptr< SourceNode_type > p);



          typedef ::xml_schema::string TargetNode_type;

          typedef ::xsd::cxx::tree::traits< TargetNode_type, char > TargetNode_traits;

          const TargetNode_type&
          TargetNode () const;

          TargetNode_type&
          TargetNode ();

          void
          TargetNode (const TargetNode_type& x);

          void
          TargetNode (::std::unique_ptr< TargetNode_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumOpenClosed Switch_type;

          typedef ::xsd::cxx::tree::optional< Switch_type > Switch_optional;

          typedef ::xsd::cxx::tree::traits< Switch_type, char > Switch_traits;

          const Switch_optional&
          Switch () const;

          Switch_optional&
          Switch ();

          void
          Switch (const Switch_type& x);

          void
          Switch (const Switch_optional& x);

          void
          Switch (::std::unique_ptr< Switch_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumOpenClosed NextSwitch_type;

          typedef ::xsd::cxx::tree::optional< NextSwitch_type > NextSwitch_optional;

          typedef ::xsd::cxx::tree::traits< NextSwitch_type, char > NextSwitch_traits;

          const NextSwitch_optional&
          NextSwitch () const;

          NextSwitch_optional&
          NextSwitch ();

          void
          NextSwitch (const NextSwitch_type& x);

          void
          NextSwitch (const NextSwitch_optional& x);

          void
          NextSwitch (::std::unique_ptr< NextSwitch_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumOpenClosed Valve_type;

          typedef ::xsd::cxx::tree::optional< Valve_type > Valve_optional;

          typedef ::xsd::cxx::tree::traits< Valve_type, char > Valve_traits;

          const Valve_optional&
          Valve () const;

          Valve_optional&
          Valve ();

          void
          Valve (const Valve_type& x);

          void
          Valve (const Valve_optional& x);

          void
          Valve (::std::unique_ptr< Valve_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumOpenClosed NextValve_type;

          typedef ::xsd::cxx::tree::optional< NextValve_type > NextValve_optional;

          typedef ::xsd::cxx::tree::traits< NextValve_type, char > NextValve_traits;

          const NextValve_optional&
          NextValve () const;

          NextValve_optional&
          NextValve ();

          void
          NextValve (const NextValve_type& x);

          void
          NextValve (const NextValve_optional& x);

          void
          NextValve (::std::unique_ptr< NextValve_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumOpenClosed PolarizedState_type;

          typedef ::xsd::cxx::tree::optional< PolarizedState_type > PolarizedState_optional;

          typedef ::xsd::cxx::tree::traits< PolarizedState_type, char > PolarizedState_traits;

          const PolarizedState_optional&
          PolarizedState () const;

          PolarizedState_optional&
          PolarizedState ();

          void
          PolarizedState (const PolarizedState_type& x);

          void
          PolarizedState (const PolarizedState_optional& x);

          void
          PolarizedState (::std::unique_ptr< PolarizedState_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumOpenClosed NextPolarizedState_type;

          typedef ::xsd::cxx::tree::optional< NextPolarizedState_type > NextPolarizedState_optional;

          typedef ::xsd::cxx::tree::traits< NextPolarizedState_type, char > NextPolarizedState_traits;

          const NextPolarizedState_optional&
          NextPolarizedState () const;

          NextPolarizedState_optional&
          NextPolarizedState ();

          void
          NextPolarizedState (const NextPolarizedState_type& x);

          void
          NextPolarizedState (const NextPolarizedState_optional& x);

          void
          NextPolarizedState (::std::unique_ptr< NextPolarizedState_type > p);



          CircuitPathData ();

          CircuitPathData (const Name_type&,
                           const SourceNode_type&,
                           const TargetNode_type&);

          CircuitPathData (::std::unique_ptr< Name_type >,
                           ::std::unique_ptr< SourceNode_type >,
                           ::std::unique_ptr< TargetNode_type >);

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

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

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

          CircuitPathData&
          operator= (const CircuitPathData& x);


          virtual 
          ~CircuitPathData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Name_type > Name_;
          ::xsd::cxx::tree::one< SourceNode_type > SourceNode_;
          ::xsd::cxx::tree::one< TargetNode_type > TargetNode_;
          Switch_optional Switch_;
          NextSwitch_optional NextSwitch_;
          Valve_optional Valve_;
          NextValve_optional NextValve_;
          PolarizedState_optional PolarizedState_;
          NextPolarizedState_optional NextPolarizedState_;

          //@endcond
        };

        class BIOGEARS_CDM_API ElectricalCircuitData: public ::mil::tatrc::physiology::datamodel::CircuitData
        {
          public:

          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 Path_type;

          typedef ::xsd::cxx::tree::sequence< Path_type > Path_sequence;

          typedef Path_sequence::iterator Path_iterator;

          typedef Path_sequence::const_iterator Path_const_iterator;

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

          const Path_sequence&
          Path () const;

          Path_sequence&
          Path ();

          void
          Path (const Path_sequence& s);



          ElectricalCircuitData ();

          ElectricalCircuitData (const Name_type&);

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

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

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

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

          ElectricalCircuitData&
          operator= (const ElectricalCircuitData& x);


          virtual 
          ~ElectricalCircuitData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Node_sequence Node_;
          Path_sequence Path_;

          //@endcond
        };

        class BIOGEARS_CDM_API ElectricalCircuitNodeData: public ::mil::tatrc::physiology::datamodel::CircuitNodeData
        {
          public:

          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::ScalarElectricPotentialData NextVoltage_type;

          typedef ::xsd::cxx::tree::optional< NextVoltage_type > NextVoltage_optional;

          typedef ::xsd::cxx::tree::traits< NextVoltage_type, char > NextVoltage_traits;

          const NextVoltage_optional&
          NextVoltage () const;

          NextVoltage_optional&
          NextVoltage ();

          void
          NextVoltage (const NextVoltage_type& x);

          void
          NextVoltage (const NextVoltage_optional& x);

          void
          NextVoltage (::std::unique_ptr< NextVoltage_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);



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

          typedef ::xsd::cxx::tree::optional< NextCharge_type > NextCharge_optional;

          typedef ::xsd::cxx::tree::traits< NextCharge_type, char > NextCharge_traits;

          const NextCharge_optional&
          NextCharge () const;

          NextCharge_optional&
          NextCharge ();

          void
          NextCharge (const NextCharge_type& x);

          void
          NextCharge (const NextCharge_optional& x);

          void
          NextCharge (::std::unique_ptr< NextCharge_type > p);



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

          typedef ::xsd::cxx::tree::optional< ChargeBaseline_type > ChargeBaseline_optional;

          typedef ::xsd::cxx::tree::traits< ChargeBaseline_type, char > ChargeBaseline_traits;

          const ChargeBaseline_optional&
          ChargeBaseline () const;

          ChargeBaseline_optional&
          ChargeBaseline ();

          void
          ChargeBaseline (const ChargeBaseline_type& x);

          void
          ChargeBaseline (const ChargeBaseline_optional& x);

          void
          ChargeBaseline (::std::unique_ptr< ChargeBaseline_type > p);



          ElectricalCircuitNodeData ();

          ElectricalCircuitNodeData (const Name_type&);

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

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

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

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

          ElectricalCircuitNodeData&
          operator= (const ElectricalCircuitNodeData& x);


          virtual 
          ~ElectricalCircuitNodeData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Voltage_optional Voltage_;
          NextVoltage_optional NextVoltage_;
          Charge_optional Charge_;
          NextCharge_optional NextCharge_;
          ChargeBaseline_optional ChargeBaseline_;

          //@endcond
        };

        class BIOGEARS_CDM_API ElectricalCircuitPathData: public ::mil::tatrc::physiology::datamodel::CircuitPathData
        {
          public:

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

          typedef ::xsd::cxx::tree::optional< Resistance_type > Resistance_optional;

          typedef ::xsd::cxx::tree::traits< Resistance_type, char > Resistance_traits;

          const Resistance_optional&
          Resistance () const;

          Resistance_optional&
          Resistance ();

          void
          Resistance (const Resistance_type& x);

          void
          Resistance (const Resistance_optional& x);

          void
          Resistance (::std::unique_ptr< Resistance_type > p);



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

          typedef ::xsd::cxx::tree::optional< NextResistance_type > NextResistance_optional;

          typedef ::xsd::cxx::tree::traits< NextResistance_type, char > NextResistance_traits;

          const NextResistance_optional&
          NextResistance () const;

          NextResistance_optional&
          NextResistance ();

          void
          NextResistance (const NextResistance_type& x);

          void
          NextResistance (const NextResistance_optional& x);

          void
          NextResistance (::std::unique_ptr< NextResistance_type > p);



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

          typedef ::xsd::cxx::tree::optional< ResistanceBaseline_type > ResistanceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< ResistanceBaseline_type, char > ResistanceBaseline_traits;

          const ResistanceBaseline_optional&
          ResistanceBaseline () const;

          ResistanceBaseline_optional&
          ResistanceBaseline ();

          void
          ResistanceBaseline (const ResistanceBaseline_type& x);

          void
          ResistanceBaseline (const ResistanceBaseline_optional& x);

          void
          ResistanceBaseline (::std::unique_ptr< ResistanceBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricCapacitanceData Capacitance_type;

          typedef ::xsd::cxx::tree::optional< Capacitance_type > Capacitance_optional;

          typedef ::xsd::cxx::tree::traits< Capacitance_type, char > Capacitance_traits;

          const Capacitance_optional&
          Capacitance () const;

          Capacitance_optional&
          Capacitance ();

          void
          Capacitance (const Capacitance_type& x);

          void
          Capacitance (const Capacitance_optional& x);

          void
          Capacitance (::std::unique_ptr< Capacitance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricCapacitanceData NextCapacitance_type;

          typedef ::xsd::cxx::tree::optional< NextCapacitance_type > NextCapacitance_optional;

          typedef ::xsd::cxx::tree::traits< NextCapacitance_type, char > NextCapacitance_traits;

          const NextCapacitance_optional&
          NextCapacitance () const;

          NextCapacitance_optional&
          NextCapacitance ();

          void
          NextCapacitance (const NextCapacitance_type& x);

          void
          NextCapacitance (const NextCapacitance_optional& x);

          void
          NextCapacitance (::std::unique_ptr< NextCapacitance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricCapacitanceData CapacitanceBaseline_type;

          typedef ::xsd::cxx::tree::optional< CapacitanceBaseline_type > CapacitanceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< CapacitanceBaseline_type, char > CapacitanceBaseline_traits;

          const CapacitanceBaseline_optional&
          CapacitanceBaseline () const;

          CapacitanceBaseline_optional&
          CapacitanceBaseline ();

          void
          CapacitanceBaseline (const CapacitanceBaseline_type& x);

          void
          CapacitanceBaseline (const CapacitanceBaseline_optional& x);

          void
          CapacitanceBaseline (::std::unique_ptr< CapacitanceBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricInductanceData Inductance_type;

          typedef ::xsd::cxx::tree::optional< Inductance_type > Inductance_optional;

          typedef ::xsd::cxx::tree::traits< Inductance_type, char > Inductance_traits;

          const Inductance_optional&
          Inductance () const;

          Inductance_optional&
          Inductance ();

          void
          Inductance (const Inductance_type& x);

          void
          Inductance (const Inductance_optional& x);

          void
          Inductance (::std::unique_ptr< Inductance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricInductanceData NextInductance_type;

          typedef ::xsd::cxx::tree::optional< NextInductance_type > NextInductance_optional;

          typedef ::xsd::cxx::tree::traits< NextInductance_type, char > NextInductance_traits;

          const NextInductance_optional&
          NextInductance () const;

          NextInductance_optional&
          NextInductance ();

          void
          NextInductance (const NextInductance_type& x);

          void
          NextInductance (const NextInductance_optional& x);

          void
          NextInductance (::std::unique_ptr< NextInductance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricInductanceData InductanceBaseline_type;

          typedef ::xsd::cxx::tree::optional< InductanceBaseline_type > InductanceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< InductanceBaseline_type, char > InductanceBaseline_traits;

          const InductanceBaseline_optional&
          InductanceBaseline () const;

          InductanceBaseline_optional&
          InductanceBaseline ();

          void
          InductanceBaseline (const InductanceBaseline_type& x);

          void
          InductanceBaseline (const InductanceBaseline_optional& x);

          void
          InductanceBaseline (::std::unique_ptr< InductanceBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarElectricCurrentData 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);



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

          typedef ::xsd::cxx::tree::optional< NextCurrent_type > NextCurrent_optional;

          typedef ::xsd::cxx::tree::traits< NextCurrent_type, char > NextCurrent_traits;

          const NextCurrent_optional&
          NextCurrent () const;

          NextCurrent_optional&
          NextCurrent ();

          void
          NextCurrent (const NextCurrent_type& x);

          void
          NextCurrent (const NextCurrent_optional& x);

          void
          NextCurrent (::std::unique_ptr< NextCurrent_type > p);



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

          typedef ::xsd::cxx::tree::optional< CurrentSource_type > CurrentSource_optional;

          typedef ::xsd::cxx::tree::traits< CurrentSource_type, char > CurrentSource_traits;

          const CurrentSource_optional&
          CurrentSource () const;

          CurrentSource_optional&
          CurrentSource ();

          void
          CurrentSource (const CurrentSource_type& x);

          void
          CurrentSource (const CurrentSource_optional& x);

          void
          CurrentSource (::std::unique_ptr< CurrentSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< NextCurrentSource_type > NextCurrentSource_optional;

          typedef ::xsd::cxx::tree::traits< NextCurrentSource_type, char > NextCurrentSource_traits;

          const NextCurrentSource_optional&
          NextCurrentSource () const;

          NextCurrentSource_optional&
          NextCurrentSource ();

          void
          NextCurrentSource (const NextCurrentSource_type& x);

          void
          NextCurrentSource (const NextCurrentSource_optional& x);

          void
          NextCurrentSource (::std::unique_ptr< NextCurrentSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< CurrentSourceBaseline_type > CurrentSourceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< CurrentSourceBaseline_type, char > CurrentSourceBaseline_traits;

          const CurrentSourceBaseline_optional&
          CurrentSourceBaseline () const;

          CurrentSourceBaseline_optional&
          CurrentSourceBaseline ();

          void
          CurrentSourceBaseline (const CurrentSourceBaseline_type& x);

          void
          CurrentSourceBaseline (const CurrentSourceBaseline_optional& x);

          void
          CurrentSourceBaseline (::std::unique_ptr< CurrentSourceBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< VoltageSource_type > VoltageSource_optional;

          typedef ::xsd::cxx::tree::traits< VoltageSource_type, char > VoltageSource_traits;

          const VoltageSource_optional&
          VoltageSource () const;

          VoltageSource_optional&
          VoltageSource ();

          void
          VoltageSource (const VoltageSource_type& x);

          void
          VoltageSource (const VoltageSource_optional& x);

          void
          VoltageSource (::std::unique_ptr< VoltageSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< NextVoltageSource_type > NextVoltageSource_optional;

          typedef ::xsd::cxx::tree::traits< NextVoltageSource_type, char > NextVoltageSource_traits;

          const NextVoltageSource_optional&
          NextVoltageSource () const;

          NextVoltageSource_optional&
          NextVoltageSource ();

          void
          NextVoltageSource (const NextVoltageSource_type& x);

          void
          NextVoltageSource (const NextVoltageSource_optional& x);

          void
          NextVoltageSource (::std::unique_ptr< NextVoltageSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< VoltageSourceBaseline_type > VoltageSourceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< VoltageSourceBaseline_type, char > VoltageSourceBaseline_traits;

          const VoltageSourceBaseline_optional&
          VoltageSourceBaseline () const;

          VoltageSourceBaseline_optional&
          VoltageSourceBaseline ();

          void
          VoltageSourceBaseline (const VoltageSourceBaseline_type& x);

          void
          VoltageSourceBaseline (const VoltageSourceBaseline_optional& x);

          void
          VoltageSourceBaseline (::std::unique_ptr< VoltageSourceBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< ValveBreakdownVoltage_type > ValveBreakdownVoltage_optional;

          typedef ::xsd::cxx::tree::traits< ValveBreakdownVoltage_type, char > ValveBreakdownVoltage_traits;

          const ValveBreakdownVoltage_optional&
          ValveBreakdownVoltage () const;

          ValveBreakdownVoltage_optional&
          ValveBreakdownVoltage ();

          void
          ValveBreakdownVoltage (const ValveBreakdownVoltage_type& x);

          void
          ValveBreakdownVoltage (const ValveBreakdownVoltage_optional& x);

          void
          ValveBreakdownVoltage (::std::unique_ptr< ValveBreakdownVoltage_type > p);



          ElectricalCircuitPathData ();

          ElectricalCircuitPathData (const Name_type&,
                                     const SourceNode_type&,
                                     const TargetNode_type&);

          ElectricalCircuitPathData (::std::unique_ptr< Name_type >,
                                     ::std::unique_ptr< SourceNode_type >,
                                     ::std::unique_ptr< TargetNode_type >);

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

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

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

          ElectricalCircuitPathData&
          operator= (const ElectricalCircuitPathData& x);


          virtual 
          ~ElectricalCircuitPathData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Resistance_optional Resistance_;
          NextResistance_optional NextResistance_;
          ResistanceBaseline_optional ResistanceBaseline_;
          Capacitance_optional Capacitance_;
          NextCapacitance_optional NextCapacitance_;
          CapacitanceBaseline_optional CapacitanceBaseline_;
          Inductance_optional Inductance_;
          NextInductance_optional NextInductance_;
          InductanceBaseline_optional InductanceBaseline_;
          Current_optional Current_;
          NextCurrent_optional NextCurrent_;
          CurrentSource_optional CurrentSource_;
          NextCurrentSource_optional NextCurrentSource_;
          CurrentSourceBaseline_optional CurrentSourceBaseline_;
          VoltageSource_optional VoltageSource_;
          NextVoltageSource_optional NextVoltageSource_;
          VoltageSourceBaseline_optional VoltageSourceBaseline_;
          ValveBreakdownVoltage_optional ValveBreakdownVoltage_;

          //@endcond
        };

        class BIOGEARS_CDM_API FluidCircuitData: public ::mil::tatrc::physiology::datamodel::CircuitData
        {
          public:

          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 Path_type;

          typedef ::xsd::cxx::tree::sequence< Path_type > Path_sequence;

          typedef Path_sequence::iterator Path_iterator;

          typedef Path_sequence::const_iterator Path_const_iterator;

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

          const Path_sequence&
          Path () const;

          Path_sequence&
          Path ();

          void
          Path (const Path_sequence& s);



          FluidCircuitData ();

          FluidCircuitData (const Name_type&);

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

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

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

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

          FluidCircuitData&
          operator= (const FluidCircuitData& x);


          virtual 
          ~FluidCircuitData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Node_sequence Node_;
          Path_sequence Path_;

          //@endcond
        };

        class BIOGEARS_CDM_API FluidCircuitNodeData: public ::mil::tatrc::physiology::datamodel::CircuitNodeData
        {
          public:

          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::ScalarPressureData NextPressure_type;

          typedef ::xsd::cxx::tree::optional< NextPressure_type > NextPressure_optional;

          typedef ::xsd::cxx::tree::traits< NextPressure_type, char > NextPressure_traits;

          const NextPressure_optional&
          NextPressure () const;

          NextPressure_optional&
          NextPressure ();

          void
          NextPressure (const NextPressure_type& x);

          void
          NextPressure (const NextPressure_optional& x);

          void
          NextPressure (::std::unique_ptr< NextPressure_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);



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

          typedef ::xsd::cxx::tree::optional< NextVolume_type > NextVolume_optional;

          typedef ::xsd::cxx::tree::traits< NextVolume_type, char > NextVolume_traits;

          const NextVolume_optional&
          NextVolume () const;

          NextVolume_optional&
          NextVolume ();

          void
          NextVolume (const NextVolume_type& x);

          void
          NextVolume (const NextVolume_optional& x);

          void
          NextVolume (::std::unique_ptr< NextVolume_type > p);



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

          typedef ::xsd::cxx::tree::optional< VolumeBaseline_type > VolumeBaseline_optional;

          typedef ::xsd::cxx::tree::traits< VolumeBaseline_type, char > VolumeBaseline_traits;

          const VolumeBaseline_optional&
          VolumeBaseline () const;

          VolumeBaseline_optional&
          VolumeBaseline ();

          void
          VolumeBaseline (const VolumeBaseline_type& x);

          void
          VolumeBaseline (const VolumeBaseline_optional& x);

          void
          VolumeBaseline (::std::unique_ptr< VolumeBaseline_type > p);



          FluidCircuitNodeData ();

          FluidCircuitNodeData (const Name_type&);

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

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

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

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

          FluidCircuitNodeData&
          operator= (const FluidCircuitNodeData& x);


          virtual 
          ~FluidCircuitNodeData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Pressure_optional Pressure_;
          NextPressure_optional NextPressure_;
          Volume_optional Volume_;
          NextVolume_optional NextVolume_;
          VolumeBaseline_optional VolumeBaseline_;

          //@endcond
        };

        class BIOGEARS_CDM_API FluidCircuitPathData: public ::mil::tatrc::physiology::datamodel::CircuitPathData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowResistanceData Resistance_type;

          typedef ::xsd::cxx::tree::optional< Resistance_type > Resistance_optional;

          typedef ::xsd::cxx::tree::traits< Resistance_type, char > Resistance_traits;

          const Resistance_optional&
          Resistance () const;

          Resistance_optional&
          Resistance ();

          void
          Resistance (const Resistance_type& x);

          void
          Resistance (const Resistance_optional& x);

          void
          Resistance (::std::unique_ptr< Resistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowResistanceData NextResistance_type;

          typedef ::xsd::cxx::tree::optional< NextResistance_type > NextResistance_optional;

          typedef ::xsd::cxx::tree::traits< NextResistance_type, char > NextResistance_traits;

          const NextResistance_optional&
          NextResistance () const;

          NextResistance_optional&
          NextResistance ();

          void
          NextResistance (const NextResistance_type& x);

          void
          NextResistance (const NextResistance_optional& x);

          void
          NextResistance (::std::unique_ptr< NextResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowResistanceData ResistanceBaseline_type;

          typedef ::xsd::cxx::tree::optional< ResistanceBaseline_type > ResistanceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< ResistanceBaseline_type, char > ResistanceBaseline_traits;

          const ResistanceBaseline_optional&
          ResistanceBaseline () const;

          ResistanceBaseline_optional&
          ResistanceBaseline ();

          void
          ResistanceBaseline (const ResistanceBaseline_type& x);

          void
          ResistanceBaseline (const ResistanceBaseline_optional& x);

          void
          ResistanceBaseline (::std::unique_ptr< ResistanceBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumResistancePathType CardiovascularRegion_type;

          typedef ::xsd::cxx::tree::optional< CardiovascularRegion_type > CardiovascularRegion_optional;

          typedef ::xsd::cxx::tree::traits< CardiovascularRegion_type, char > CardiovascularRegion_traits;

          const CardiovascularRegion_optional&
          CardiovascularRegion () const;

          CardiovascularRegion_optional&
          CardiovascularRegion ();

          void
          CardiovascularRegion (const CardiovascularRegion_type& x);

          void
          CardiovascularRegion (const CardiovascularRegion_optional& x);

          void
          CardiovascularRegion (::std::unique_ptr< CardiovascularRegion_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowComplianceData Compliance_type;

          typedef ::xsd::cxx::tree::optional< Compliance_type > Compliance_optional;

          typedef ::xsd::cxx::tree::traits< Compliance_type, char > Compliance_traits;

          const Compliance_optional&
          Compliance () const;

          Compliance_optional&
          Compliance ();

          void
          Compliance (const Compliance_type& x);

          void
          Compliance (const Compliance_optional& x);

          void
          Compliance (::std::unique_ptr< Compliance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowComplianceData NextCompliance_type;

          typedef ::xsd::cxx::tree::optional< NextCompliance_type > NextCompliance_optional;

          typedef ::xsd::cxx::tree::traits< NextCompliance_type, char > NextCompliance_traits;

          const NextCompliance_optional&
          NextCompliance () const;

          NextCompliance_optional&
          NextCompliance ();

          void
          NextCompliance (const NextCompliance_type& x);

          void
          NextCompliance (const NextCompliance_optional& x);

          void
          NextCompliance (::std::unique_ptr< NextCompliance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowComplianceData ComplianceBaseline_type;

          typedef ::xsd::cxx::tree::optional< ComplianceBaseline_type > ComplianceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< ComplianceBaseline_type, char > ComplianceBaseline_traits;

          const ComplianceBaseline_optional&
          ComplianceBaseline () const;

          ComplianceBaseline_optional&
          ComplianceBaseline ();

          void
          ComplianceBaseline (const ComplianceBaseline_type& x);

          void
          ComplianceBaseline (const ComplianceBaseline_optional& x);

          void
          ComplianceBaseline (::std::unique_ptr< ComplianceBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowInertanceData Inertance_type;

          typedef ::xsd::cxx::tree::optional< Inertance_type > Inertance_optional;

          typedef ::xsd::cxx::tree::traits< Inertance_type, char > Inertance_traits;

          const Inertance_optional&
          Inertance () const;

          Inertance_optional&
          Inertance ();

          void
          Inertance (const Inertance_type& x);

          void
          Inertance (const Inertance_optional& x);

          void
          Inertance (::std::unique_ptr< Inertance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowInertanceData NextInertance_type;

          typedef ::xsd::cxx::tree::optional< NextInertance_type > NextInertance_optional;

          typedef ::xsd::cxx::tree::traits< NextInertance_type, char > NextInertance_traits;

          const NextInertance_optional&
          NextInertance () const;

          NextInertance_optional&
          NextInertance ();

          void
          NextInertance (const NextInertance_type& x);

          void
          NextInertance (const NextInertance_optional& x);

          void
          NextInertance (::std::unique_ptr< NextInertance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarFlowInertanceData InertanceBaseline_type;

          typedef ::xsd::cxx::tree::optional< InertanceBaseline_type > InertanceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< InertanceBaseline_type, char > InertanceBaseline_traits;

          const InertanceBaseline_optional&
          InertanceBaseline () const;

          InertanceBaseline_optional&
          InertanceBaseline ();

          void
          InertanceBaseline (const InertanceBaseline_type& x);

          void
          InertanceBaseline (const InertanceBaseline_optional& x);

          void
          InertanceBaseline (::std::unique_ptr< InertanceBaseline_type > p);



          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);



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

          typedef ::xsd::cxx::tree::optional< NextFlow_type > NextFlow_optional;

          typedef ::xsd::cxx::tree::traits< NextFlow_type, char > NextFlow_traits;

          const NextFlow_optional&
          NextFlow () const;

          NextFlow_optional&
          NextFlow ();

          void
          NextFlow (const NextFlow_type& x);

          void
          NextFlow (const NextFlow_optional& x);

          void
          NextFlow (::std::unique_ptr< NextFlow_type > p);



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

          typedef ::xsd::cxx::tree::optional< FlowSource_type > FlowSource_optional;

          typedef ::xsd::cxx::tree::traits< FlowSource_type, char > FlowSource_traits;

          const FlowSource_optional&
          FlowSource () const;

          FlowSource_optional&
          FlowSource ();

          void
          FlowSource (const FlowSource_type& x);

          void
          FlowSource (const FlowSource_optional& x);

          void
          FlowSource (::std::unique_ptr< FlowSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< NextFlowSource_type > NextFlowSource_optional;

          typedef ::xsd::cxx::tree::traits< NextFlowSource_type, char > NextFlowSource_traits;

          const NextFlowSource_optional&
          NextFlowSource () const;

          NextFlowSource_optional&
          NextFlowSource ();

          void
          NextFlowSource (const NextFlowSource_type& x);

          void
          NextFlowSource (const NextFlowSource_optional& x);

          void
          NextFlowSource (::std::unique_ptr< NextFlowSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< FlowSourceBaseline_type > FlowSourceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< FlowSourceBaseline_type, char > FlowSourceBaseline_traits;

          const FlowSourceBaseline_optional&
          FlowSourceBaseline () const;

          FlowSourceBaseline_optional&
          FlowSourceBaseline ();

          void
          FlowSourceBaseline (const FlowSourceBaseline_type& x);

          void
          FlowSourceBaseline (const FlowSourceBaseline_optional& x);

          void
          FlowSourceBaseline (::std::unique_ptr< FlowSourceBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< PressureSource_type > PressureSource_optional;

          typedef ::xsd::cxx::tree::traits< PressureSource_type, char > PressureSource_traits;

          const PressureSource_optional&
          PressureSource () const;

          PressureSource_optional&
          PressureSource ();

          void
          PressureSource (const PressureSource_type& x);

          void
          PressureSource (const PressureSource_optional& x);

          void
          PressureSource (::std::unique_ptr< PressureSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< NextPressureSource_type > NextPressureSource_optional;

          typedef ::xsd::cxx::tree::traits< NextPressureSource_type, char > NextPressureSource_traits;

          const NextPressureSource_optional&
          NextPressureSource () const;

          NextPressureSource_optional&
          NextPressureSource ();

          void
          NextPressureSource (const NextPressureSource_type& x);

          void
          NextPressureSource (const NextPressureSource_optional& x);

          void
          NextPressureSource (::std::unique_ptr< NextPressureSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< PressureSourceBaseline_type > PressureSourceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< PressureSourceBaseline_type, char > PressureSourceBaseline_traits;

          const PressureSourceBaseline_optional&
          PressureSourceBaseline () const;

          PressureSourceBaseline_optional&
          PressureSourceBaseline ();

          void
          PressureSourceBaseline (const PressureSourceBaseline_type& x);

          void
          PressureSourceBaseline (const PressureSourceBaseline_optional& x);

          void
          PressureSourceBaseline (::std::unique_ptr< PressureSourceBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< ValveBreakdownPressure_type > ValveBreakdownPressure_optional;

          typedef ::xsd::cxx::tree::traits< ValveBreakdownPressure_type, char > ValveBreakdownPressure_traits;

          const ValveBreakdownPressure_optional&
          ValveBreakdownPressure () const;

          ValveBreakdownPressure_optional&
          ValveBreakdownPressure ();

          void
          ValveBreakdownPressure (const ValveBreakdownPressure_type& x);

          void
          ValveBreakdownPressure (const ValveBreakdownPressure_optional& x);

          void
          ValveBreakdownPressure (::std::unique_ptr< ValveBreakdownPressure_type > p);



          FluidCircuitPathData ();

          FluidCircuitPathData (const Name_type&,
                                const SourceNode_type&,
                                const TargetNode_type&);

          FluidCircuitPathData (::std::unique_ptr< Name_type >,
                                ::std::unique_ptr< SourceNode_type >,
                                ::std::unique_ptr< TargetNode_type >);

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

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

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

          FluidCircuitPathData&
          operator= (const FluidCircuitPathData& x);


          virtual 
          ~FluidCircuitPathData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Resistance_optional Resistance_;
          NextResistance_optional NextResistance_;
          ResistanceBaseline_optional ResistanceBaseline_;
          CardiovascularRegion_optional CardiovascularRegion_;
          Compliance_optional Compliance_;
          NextCompliance_optional NextCompliance_;
          ComplianceBaseline_optional ComplianceBaseline_;
          Inertance_optional Inertance_;
          NextInertance_optional NextInertance_;
          InertanceBaseline_optional InertanceBaseline_;
          Flow_optional Flow_;
          NextFlow_optional NextFlow_;
          FlowSource_optional FlowSource_;
          NextFlowSource_optional NextFlowSource_;
          FlowSourceBaseline_optional FlowSourceBaseline_;
          PressureSource_optional PressureSource_;
          NextPressureSource_optional NextPressureSource_;
          PressureSourceBaseline_optional PressureSourceBaseline_;
          ValveBreakdownPressure_optional ValveBreakdownPressure_;

          //@endcond
        };

        class BIOGEARS_CDM_API ThermalCircuitData: public ::mil::tatrc::physiology::datamodel::CircuitData
        {
          public:

          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 Path_type;

          typedef ::xsd::cxx::tree::sequence< Path_type > Path_sequence;

          typedef Path_sequence::iterator Path_iterator;

          typedef Path_sequence::const_iterator Path_const_iterator;

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

          const Path_sequence&
          Path () const;

          Path_sequence&
          Path ();

          void
          Path (const Path_sequence& s);



          ThermalCircuitData ();

          ThermalCircuitData (const Name_type&);

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

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

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

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

          ThermalCircuitData&
          operator= (const ThermalCircuitData& x);


          virtual 
          ~ThermalCircuitData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Node_sequence Node_;
          Path_sequence Path_;

          //@endcond
        };

        class BIOGEARS_CDM_API ThermalCircuitNodeData: public ::mil::tatrc::physiology::datamodel::CircuitNodeData
        {
          public:

          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::ScalarTemperatureData NextTemperature_type;

          typedef ::xsd::cxx::tree::optional< NextTemperature_type > NextTemperature_optional;

          typedef ::xsd::cxx::tree::traits< NextTemperature_type, char > NextTemperature_traits;

          const NextTemperature_optional&
          NextTemperature () const;

          NextTemperature_optional&
          NextTemperature ();

          void
          NextTemperature (const NextTemperature_type& x);

          void
          NextTemperature (const NextTemperature_optional& x);

          void
          NextTemperature (::std::unique_ptr< NextTemperature_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);



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

          typedef ::xsd::cxx::tree::optional< NextHeat_type > NextHeat_optional;

          typedef ::xsd::cxx::tree::traits< NextHeat_type, char > NextHeat_traits;

          const NextHeat_optional&
          NextHeat () const;

          NextHeat_optional&
          NextHeat ();

          void
          NextHeat (const NextHeat_type& x);

          void
          NextHeat (const NextHeat_optional& x);

          void
          NextHeat (::std::unique_ptr< NextHeat_type > p);



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

          typedef ::xsd::cxx::tree::optional< HeatBaseline_type > HeatBaseline_optional;

          typedef ::xsd::cxx::tree::traits< HeatBaseline_type, char > HeatBaseline_traits;

          const HeatBaseline_optional&
          HeatBaseline () const;

          HeatBaseline_optional&
          HeatBaseline ();

          void
          HeatBaseline (const HeatBaseline_type& x);

          void
          HeatBaseline (const HeatBaseline_optional& x);

          void
          HeatBaseline (::std::unique_ptr< HeatBaseline_type > p);



          ThermalCircuitNodeData ();

          ThermalCircuitNodeData (const Name_type&);

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

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

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

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

          ThermalCircuitNodeData&
          operator= (const ThermalCircuitNodeData& x);


          virtual 
          ~ThermalCircuitNodeData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Temperature_optional Temperature_;
          NextTemperature_optional NextTemperature_;
          Heat_optional Heat_;
          NextHeat_optional NextHeat_;
          HeatBaseline_optional HeatBaseline_;

          //@endcond
        };

        class BIOGEARS_CDM_API ThermalCircuitPathData: public ::mil::tatrc::physiology::datamodel::CircuitPathData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatResistanceData Resistance_type;

          typedef ::xsd::cxx::tree::optional< Resistance_type > Resistance_optional;

          typedef ::xsd::cxx::tree::traits< Resistance_type, char > Resistance_traits;

          const Resistance_optional&
          Resistance () const;

          Resistance_optional&
          Resistance ();

          void
          Resistance (const Resistance_type& x);

          void
          Resistance (const Resistance_optional& x);

          void
          Resistance (::std::unique_ptr< Resistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatResistanceData NextResistance_type;

          typedef ::xsd::cxx::tree::optional< NextResistance_type > NextResistance_optional;

          typedef ::xsd::cxx::tree::traits< NextResistance_type, char > NextResistance_traits;

          const NextResistance_optional&
          NextResistance () const;

          NextResistance_optional&
          NextResistance ();

          void
          NextResistance (const NextResistance_type& x);

          void
          NextResistance (const NextResistance_optional& x);

          void
          NextResistance (::std::unique_ptr< NextResistance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatResistanceData ResistanceBaseline_type;

          typedef ::xsd::cxx::tree::optional< ResistanceBaseline_type > ResistanceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< ResistanceBaseline_type, char > ResistanceBaseline_traits;

          const ResistanceBaseline_optional&
          ResistanceBaseline () const;

          ResistanceBaseline_optional&
          ResistanceBaseline ();

          void
          ResistanceBaseline (const ResistanceBaseline_type& x);

          void
          ResistanceBaseline (const ResistanceBaseline_optional& x);

          void
          ResistanceBaseline (::std::unique_ptr< ResistanceBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatCapacitanceData Capacitance_type;

          typedef ::xsd::cxx::tree::optional< Capacitance_type > Capacitance_optional;

          typedef ::xsd::cxx::tree::traits< Capacitance_type, char > Capacitance_traits;

          const Capacitance_optional&
          Capacitance () const;

          Capacitance_optional&
          Capacitance ();

          void
          Capacitance (const Capacitance_type& x);

          void
          Capacitance (const Capacitance_optional& x);

          void
          Capacitance (::std::unique_ptr< Capacitance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatCapacitanceData NextCapacitance_type;

          typedef ::xsd::cxx::tree::optional< NextCapacitance_type > NextCapacitance_optional;

          typedef ::xsd::cxx::tree::traits< NextCapacitance_type, char > NextCapacitance_traits;

          const NextCapacitance_optional&
          NextCapacitance () const;

          NextCapacitance_optional&
          NextCapacitance ();

          void
          NextCapacitance (const NextCapacitance_type& x);

          void
          NextCapacitance (const NextCapacitance_optional& x);

          void
          NextCapacitance (::std::unique_ptr< NextCapacitance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatCapacitanceData CapacitanceBaseline_type;

          typedef ::xsd::cxx::tree::optional< CapacitanceBaseline_type > CapacitanceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< CapacitanceBaseline_type, char > CapacitanceBaseline_traits;

          const CapacitanceBaseline_optional&
          CapacitanceBaseline () const;

          CapacitanceBaseline_optional&
          CapacitanceBaseline ();

          void
          CapacitanceBaseline (const CapacitanceBaseline_type& x);

          void
          CapacitanceBaseline (const CapacitanceBaseline_optional& x);

          void
          CapacitanceBaseline (::std::unique_ptr< CapacitanceBaseline_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatInductanceData Inductance_type;

          typedef ::xsd::cxx::tree::optional< Inductance_type > Inductance_optional;

          typedef ::xsd::cxx::tree::traits< Inductance_type, char > Inductance_traits;

          const Inductance_optional&
          Inductance () const;

          Inductance_optional&
          Inductance ();

          void
          Inductance (const Inductance_type& x);

          void
          Inductance (const Inductance_optional& x);

          void
          Inductance (::std::unique_ptr< Inductance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatInductanceData NextInductance_type;

          typedef ::xsd::cxx::tree::optional< NextInductance_type > NextInductance_optional;

          typedef ::xsd::cxx::tree::traits< NextInductance_type, char > NextInductance_traits;

          const NextInductance_optional&
          NextInductance () const;

          NextInductance_optional&
          NextInductance ();

          void
          NextInductance (const NextInductance_type& x);

          void
          NextInductance (const NextInductance_optional& x);

          void
          NextInductance (::std::unique_ptr< NextInductance_type > p);



          typedef ::mil::tatrc::physiology::datamodel::ScalarHeatInductanceData InductanceBaseline_type;

          typedef ::xsd::cxx::tree::optional< InductanceBaseline_type > InductanceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< InductanceBaseline_type, char > InductanceBaseline_traits;

          const InductanceBaseline_optional&
          InductanceBaseline () const;

          InductanceBaseline_optional&
          InductanceBaseline ();

          void
          InductanceBaseline (const InductanceBaseline_type& x);

          void
          InductanceBaseline (const InductanceBaseline_optional& x);

          void
          InductanceBaseline (::std::unique_ptr< InductanceBaseline_type > p);



          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);



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

          typedef ::xsd::cxx::tree::optional< NextHeatTransferRate_type > NextHeatTransferRate_optional;

          typedef ::xsd::cxx::tree::traits< NextHeatTransferRate_type, char > NextHeatTransferRate_traits;

          const NextHeatTransferRate_optional&
          NextHeatTransferRate () const;

          NextHeatTransferRate_optional&
          NextHeatTransferRate ();

          void
          NextHeatTransferRate (const NextHeatTransferRate_type& x);

          void
          NextHeatTransferRate (const NextHeatTransferRate_optional& x);

          void
          NextHeatTransferRate (::std::unique_ptr< NextHeatTransferRate_type > p);



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

          typedef ::xsd::cxx::tree::optional< HeatSource_type > HeatSource_optional;

          typedef ::xsd::cxx::tree::traits< HeatSource_type, char > HeatSource_traits;

          const HeatSource_optional&
          HeatSource () const;

          HeatSource_optional&
          HeatSource ();

          void
          HeatSource (const HeatSource_type& x);

          void
          HeatSource (const HeatSource_optional& x);

          void
          HeatSource (::std::unique_ptr< HeatSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< NextHeatSource_type > NextHeatSource_optional;

          typedef ::xsd::cxx::tree::traits< NextHeatSource_type, char > NextHeatSource_traits;

          const NextHeatSource_optional&
          NextHeatSource () const;

          NextHeatSource_optional&
          NextHeatSource ();

          void
          NextHeatSource (const NextHeatSource_type& x);

          void
          NextHeatSource (const NextHeatSource_optional& x);

          void
          NextHeatSource (::std::unique_ptr< NextHeatSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< HeatSourceBaseline_type > HeatSourceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< HeatSourceBaseline_type, char > HeatSourceBaseline_traits;

          const HeatSourceBaseline_optional&
          HeatSourceBaseline () const;

          HeatSourceBaseline_optional&
          HeatSourceBaseline ();

          void
          HeatSourceBaseline (const HeatSourceBaseline_type& x);

          void
          HeatSourceBaseline (const HeatSourceBaseline_optional& x);

          void
          HeatSourceBaseline (::std::unique_ptr< HeatSourceBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< TemperatureSource_type > TemperatureSource_optional;

          typedef ::xsd::cxx::tree::traits< TemperatureSource_type, char > TemperatureSource_traits;

          const TemperatureSource_optional&
          TemperatureSource () const;

          TemperatureSource_optional&
          TemperatureSource ();

          void
          TemperatureSource (const TemperatureSource_type& x);

          void
          TemperatureSource (const TemperatureSource_optional& x);

          void
          TemperatureSource (::std::unique_ptr< TemperatureSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< NextTemperatureSource_type > NextTemperatureSource_optional;

          typedef ::xsd::cxx::tree::traits< NextTemperatureSource_type, char > NextTemperatureSource_traits;

          const NextTemperatureSource_optional&
          NextTemperatureSource () const;

          NextTemperatureSource_optional&
          NextTemperatureSource ();

          void
          NextTemperatureSource (const NextTemperatureSource_type& x);

          void
          NextTemperatureSource (const NextTemperatureSource_optional& x);

          void
          NextTemperatureSource (::std::unique_ptr< NextTemperatureSource_type > p);



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

          typedef ::xsd::cxx::tree::optional< TemperatureSourceBaseline_type > TemperatureSourceBaseline_optional;

          typedef ::xsd::cxx::tree::traits< TemperatureSourceBaseline_type, char > TemperatureSourceBaseline_traits;

          const TemperatureSourceBaseline_optional&
          TemperatureSourceBaseline () const;

          TemperatureSourceBaseline_optional&
          TemperatureSourceBaseline ();

          void
          TemperatureSourceBaseline (const TemperatureSourceBaseline_type& x);

          void
          TemperatureSourceBaseline (const TemperatureSourceBaseline_optional& x);

          void
          TemperatureSourceBaseline (::std::unique_ptr< TemperatureSourceBaseline_type > p);



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

          typedef ::xsd::cxx::tree::optional< ValveBreakdownTemperature_type > ValveBreakdownTemperature_optional;

          typedef ::xsd::cxx::tree::traits< ValveBreakdownTemperature_type, char > ValveBreakdownTemperature_traits;

          const ValveBreakdownTemperature_optional&
          ValveBreakdownTemperature () const;

          ValveBreakdownTemperature_optional&
          ValveBreakdownTemperature ();

          void
          ValveBreakdownTemperature (const ValveBreakdownTemperature_type& x);

          void
          ValveBreakdownTemperature (const ValveBreakdownTemperature_optional& x);

          void
          ValveBreakdownTemperature (::std::unique_ptr< ValveBreakdownTemperature_type > p);



          ThermalCircuitPathData ();

          ThermalCircuitPathData (const Name_type&,
                                  const SourceNode_type&,
                                  const TargetNode_type&);

          ThermalCircuitPathData (::std::unique_ptr< Name_type >,
                                  ::std::unique_ptr< SourceNode_type >,
                                  ::std::unique_ptr< TargetNode_type >);

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

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

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

          ThermalCircuitPathData&
          operator= (const ThermalCircuitPathData& x);


          virtual 
          ~ThermalCircuitPathData ();

          // Implementation.
          //

          //@cond

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

          protected:
          Resistance_optional Resistance_;
          NextResistance_optional NextResistance_;
          ResistanceBaseline_optional ResistanceBaseline_;
          Capacitance_optional Capacitance_;
          NextCapacitance_optional NextCapacitance_;
          CapacitanceBaseline_optional CapacitanceBaseline_;
          Inductance_optional Inductance_;
          NextInductance_optional NextInductance_;
          InductanceBaseline_optional InductanceBaseline_;
          HeatTransferRate_optional HeatTransferRate_;
          NextHeatTransferRate_optional NextHeatTransferRate_;
          HeatSource_optional HeatSource_;
          NextHeatSource_optional NextHeatSource_;
          HeatSourceBaseline_optional HeatSourceBaseline_;
          TemperatureSource_optional TemperatureSource_;
          NextTemperatureSource_optional NextTemperatureSource_;
          TemperatureSourceBaseline_optional TemperatureSourceBaseline_;
          ValveBreakdownTemperature_optional ValveBreakdownTemperature_;

          //@endcond
        };

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

          typedef ::mil::tatrc::physiology::datamodel::ElectricalCircuitNodeData ElectricalNode_type;

          typedef ::xsd::cxx::tree::sequence< ElectricalNode_type > ElectricalNode_sequence;

          typedef ElectricalNode_sequence::iterator ElectricalNode_iterator;

          typedef ElectricalNode_sequence::const_iterator ElectricalNode_const_iterator;

          typedef ::xsd::cxx::tree::traits< ElectricalNode_type, char > ElectricalNode_traits;

          const ElectricalNode_sequence&
          ElectricalNode () const;

          ElectricalNode_sequence&
          ElectricalNode ();

          void
          ElectricalNode (const ElectricalNode_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::ElectricalCircuitPathData ElectricalPath_type;

          typedef ::xsd::cxx::tree::sequence< ElectricalPath_type > ElectricalPath_sequence;

          typedef ElectricalPath_sequence::iterator ElectricalPath_iterator;

          typedef ElectricalPath_sequence::const_iterator ElectricalPath_const_iterator;

          typedef ::xsd::cxx::tree::traits< ElectricalPath_type, char > ElectricalPath_traits;

          const ElectricalPath_sequence&
          ElectricalPath () const;

          ElectricalPath_sequence&
          ElectricalPath ();

          void
          ElectricalPath (const ElectricalPath_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::ElectricalCircuitData ElectricalCircuit_type;

          typedef ::xsd::cxx::tree::sequence< ElectricalCircuit_type > ElectricalCircuit_sequence;

          typedef ElectricalCircuit_sequence::iterator ElectricalCircuit_iterator;

          typedef ElectricalCircuit_sequence::const_iterator ElectricalCircuit_const_iterator;

          typedef ::xsd::cxx::tree::traits< ElectricalCircuit_type, char > ElectricalCircuit_traits;

          const ElectricalCircuit_sequence&
          ElectricalCircuit () const;

          ElectricalCircuit_sequence&
          ElectricalCircuit ();

          void
          ElectricalCircuit (const ElectricalCircuit_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::FluidCircuitNodeData FluidNode_type;

          typedef ::xsd::cxx::tree::sequence< FluidNode_type > FluidNode_sequence;

          typedef FluidNode_sequence::iterator FluidNode_iterator;

          typedef FluidNode_sequence::const_iterator FluidNode_const_iterator;

          typedef ::xsd::cxx::tree::traits< FluidNode_type, char > FluidNode_traits;

          const FluidNode_sequence&
          FluidNode () const;

          FluidNode_sequence&
          FluidNode ();

          void
          FluidNode (const FluidNode_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::FluidCircuitPathData FluidPath_type;

          typedef ::xsd::cxx::tree::sequence< FluidPath_type > FluidPath_sequence;

          typedef FluidPath_sequence::iterator FluidPath_iterator;

          typedef FluidPath_sequence::const_iterator FluidPath_const_iterator;

          typedef ::xsd::cxx::tree::traits< FluidPath_type, char > FluidPath_traits;

          const FluidPath_sequence&
          FluidPath () const;

          FluidPath_sequence&
          FluidPath ();

          void
          FluidPath (const FluidPath_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::FluidCircuitData FluidCircuit_type;

          typedef ::xsd::cxx::tree::sequence< FluidCircuit_type > FluidCircuit_sequence;

          typedef FluidCircuit_sequence::iterator FluidCircuit_iterator;

          typedef FluidCircuit_sequence::const_iterator FluidCircuit_const_iterator;

          typedef ::xsd::cxx::tree::traits< FluidCircuit_type, char > FluidCircuit_traits;

          const FluidCircuit_sequence&
          FluidCircuit () const;

          FluidCircuit_sequence&
          FluidCircuit ();

          void
          FluidCircuit (const FluidCircuit_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::ThermalCircuitNodeData ThermalNode_type;

          typedef ::xsd::cxx::tree::sequence< ThermalNode_type > ThermalNode_sequence;

          typedef ThermalNode_sequence::iterator ThermalNode_iterator;

          typedef ThermalNode_sequence::const_iterator ThermalNode_const_iterator;

          typedef ::xsd::cxx::tree::traits< ThermalNode_type, char > ThermalNode_traits;

          const ThermalNode_sequence&
          ThermalNode () const;

          ThermalNode_sequence&
          ThermalNode ();

          void
          ThermalNode (const ThermalNode_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::ThermalCircuitPathData ThermalPath_type;

          typedef ::xsd::cxx::tree::sequence< ThermalPath_type > ThermalPath_sequence;

          typedef ThermalPath_sequence::iterator ThermalPath_iterator;

          typedef ThermalPath_sequence::const_iterator ThermalPath_const_iterator;

          typedef ::xsd::cxx::tree::traits< ThermalPath_type, char > ThermalPath_traits;

          const ThermalPath_sequence&
          ThermalPath () const;

          ThermalPath_sequence&
          ThermalPath ();

          void
          ThermalPath (const ThermalPath_sequence& s);



          typedef ::mil::tatrc::physiology::datamodel::ThermalCircuitData ThermalCircuit_type;

          typedef ::xsd::cxx::tree::sequence< ThermalCircuit_type > ThermalCircuit_sequence;

          typedef ThermalCircuit_sequence::iterator ThermalCircuit_iterator;

          typedef ThermalCircuit_sequence::const_iterator ThermalCircuit_const_iterator;

          typedef ::xsd::cxx::tree::traits< ThermalCircuit_type, char > ThermalCircuit_traits;

          const ThermalCircuit_sequence&
          ThermalCircuit () const;

          ThermalCircuit_sequence&
          ThermalCircuit ();

          void
          ThermalCircuit (const ThermalCircuit_sequence& s);



          CircuitManagerData ();

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

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

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

          CircuitManagerData&
          operator= (const CircuitManagerData& x);


          virtual 
          ~CircuitManagerData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ElectricalNode_sequence ElectricalNode_;
          ElectricalPath_sequence ElectricalPath_;
          ElectricalCircuit_sequence ElectricalCircuit_;
          FluidNode_sequence FluidNode_;
          FluidPath_sequence FluidPath_;
          FluidCircuit_sequence FluidCircuit_;
          ThermalNode_sequence ThermalNode_;
          ThermalPath_sequence ThermalPath_;
          ThermalCircuit_sequence ThermalCircuit_;

          //@endcond
        };
      }
    }
  }
}

#include <iosfwd>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#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::CircuitManagerData >
        CircuitManager (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::CircuitManagerData >
        CircuitManager (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::CircuitManagerData >
        CircuitManager (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::CircuitManagerData >
        CircuitManager (::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::CircuitManagerData >
        CircuitManager (::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::CircuitManagerData >
        CircuitManager (::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::CircuitManagerData >
        CircuitManager (::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::CircuitManagerData >
        CircuitManager (::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::CircuitManagerData >
        CircuitManager (::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::CircuitManagerData >
        CircuitManager (::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::CircuitManagerData >
        CircuitManager (::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::CircuitManagerData >
        CircuitManager (::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::CircuitManagerData >
        CircuitManager (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::CircuitManagerData >
        CircuitManager (::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 enumCircuitType&);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

        BIOGEARS_CDM_API
        ::xml_schema::dom::unique_ptr< ::xercesc::DOMDocument >
        CircuitManager (const ::mil::tatrc::physiology::datamodel::CircuitManagerData& 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_CIRCUIT_HXX