Properties.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_PROPERTIES_HXX
#define D__BIOGEARS_CORE_SHARE_XSD__CDM_PROPERTIES_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 PropertyData;
        class ObjectData;
        class enumDecimalFormat;
        class DecimalFormatData;
        class IntegerArray;
        class DoubleArray;
        class enumSide;
        class enumOpenClosed;
        class enumOnOff;
        class enumErrorType;
        class ErrorData;
        class ErrorList;
        class RunningAverageData;
        class ScalarData;
        class ScalarFractionData;
        class Bound0To1Double;
        class Scalar0To1Data;
        class BoundNeg1To1Double;
        class ScalarNeg1To1Data;
        class ScalarAmountData;
        class ScalarAmountPerMassData;
        class ScalarAmountPerTimeData;
        class ScalarAmountPerVolumeData;
        class ScalarAreaData;
        class ScalarAreaPerTimePressureData;
        class ScalarElectricCapacitanceData;
        class ScalarElectricChargeData;
        class ScalarElectricCurrentData;
        class ScalarElectricPotentialData;
        class ScalarElectricInductanceData;
        class ScalarElectricResistanceData;
        class ScalarEnergyData;
        class ScalarEnergyPerAmountData;
        class ScalarEnergyPerMassData;
        class ScalarFlowResistanceData;
        class ScalarFlowComplianceData;
        class ScalarFlowElastanceData;
        class ScalarFlowInertanceData;
        class ScalarForceData;
        class ScalarFrequencyData;
        class ScalarHeatCapacitanceData;
        class ScalarHeatCapacitancePerAmountData;
        class ScalarHeatCapacitancePerMassData;
        class ScalarHeatConductanceData;
        class ScalarHeatConductancePerAreaData;
        class ScalarHeatInductanceData;
        class ScalarHeatResistanceData;
        class ScalarHeatResistanceAreaData;
        class ScalarInversePressureData;
        class ScalarInverseVolumeData;
        class ScalarLengthData;
        class ScalarLengthPerTimeData;
        class ScalarLengthPerTimePressureData;
        class ScalarMassData;
        class ScalarMassPerAmountData;
        class ScalarMassPerAreaTimeData;
        class ScalarMassPerMassData;
        class ScalarMassPerTimeData;
        class ScalarMassPerVolumeData;
        class ScalarTimeMassPerVolumeData;
        class ScalarOsmolalityData;
        class ScalarOsmolarityData;
        class ScalarPowerData;
        class ScalarPowerPerAreaTemperatureToTheFourthData;
        class ScalarPressureData;
        class ScalarPressurePerVolumeData;
        class ScalarPressureTimePerVolumeAreaData;
        class ScalarPressureTimePerAreaData;
        class ScalarTimeData;
        class ScalarTemperatureData;
        class ScalarVolumeData;
        class ScalarVolumePerTimeData;
        class ScalarVolumePerPressureData;
        class ScalarVolumePerTimeAreaData;
        class ScalarVolumePerTimeMassData;
        class ScalarVolumePerTimePressureData;
        class ScalarVolumePerTimePressureAreaData;
        class ArrayData;
        class ArrayTimeData;
        class FunctionData;
        class FunctionVolumeVsTimeData;
        class FunctionElectricPotentialVsTimeData;
        class HistogramData;
        class HistogramFractionVsLengthData;
        class IntegerList;
        class DoubleList;
      }
    }
  }
}


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

namespace mil
{
  namespace tatrc
  {
    namespace physiology
    {
      namespace datamodel
      {
        class BIOGEARS_CDM_API PropertyData: public ::xml_schema::type
        {
          public:

          PropertyData ();

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

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

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

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

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


          virtual 
          ~PropertyData ();
        };

        class BIOGEARS_CDM_API ObjectData: public ::xml_schema::type
        {
          public:

          typedef ::xml_schema::string contentVersion_type;

          typedef ::xsd::cxx::tree::optional< contentVersion_type > contentVersion_optional;

          typedef ::xsd::cxx::tree::traits< contentVersion_type, char > contentVersion_traits;

          const contentVersion_optional&
          contentVersion () const;

          contentVersion_optional&
          contentVersion ();

          void
          contentVersion (const contentVersion_type& x);

          void
          contentVersion (const contentVersion_optional& x);

          void
          contentVersion (::std::unique_ptr< contentVersion_type > p);



          ObjectData ();

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

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

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

          ObjectData&
          operator= (const ObjectData& x);


          virtual 
          ~ObjectData ();

          // Implementation.
          //

          //@cond

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

          protected:
          contentVersion_optional contentVersion_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumDecimalFormat: public ::xml_schema::string
        {
          public:

          enum value
          {
            FixedMantissa,
            SignificantDigits
          };

          enumDecimalFormat ();

          enumDecimalFormat (value v);

          enumDecimalFormat (const char* v);

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

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

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

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

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

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

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

          enumDecimalFormat&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumDecimalFormat_convert () const;

          public:
          static const char* const _xsd_enumDecimalFormat_literals_[2];
          static const value _xsd_enumDecimalFormat_indexes_[2];

          //@endcond
        };

        class BIOGEARS_CDM_API DecimalFormatData: public ::xml_schema::type
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::enumDecimalFormat DecimalFormat_type;

          typedef ::xsd::cxx::tree::optional< DecimalFormat_type > DecimalFormat_optional;

          typedef ::xsd::cxx::tree::traits< DecimalFormat_type, char > DecimalFormat_traits;

          const DecimalFormat_optional&
          DecimalFormat () const;

          DecimalFormat_optional&
          DecimalFormat ();

          void
          DecimalFormat (const DecimalFormat_type& x);

          void
          DecimalFormat (const DecimalFormat_optional& x);

          void
          DecimalFormat (::std::unique_ptr< DecimalFormat_type > p);



          typedef ::xml_schema::unsigned_int Precision_type;

          typedef ::xsd::cxx::tree::optional< Precision_type > Precision_optional;

          typedef ::xsd::cxx::tree::traits< Precision_type, char > Precision_traits;

          const Precision_optional&
          Precision () const;

          Precision_optional&
          Precision ();

          void
          Precision (const Precision_type& x);

          void
          Precision (const Precision_optional& x);



          DecimalFormatData ();

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

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

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

          DecimalFormatData&
          operator= (const DecimalFormatData& x);


          virtual 
          ~DecimalFormatData ();

          // Implementation.
          //

          //@cond

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

          protected:
          DecimalFormat_optional DecimalFormat_;
          Precision_optional Precision_;

          //@endcond
        };

        class BIOGEARS_CDM_API IntegerArray: public ::xml_schema::type
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::IntegerList IntegerList_type;

          typedef ::xsd::cxx::tree::traits< IntegerList_type, char > IntegerList_traits;

          const IntegerList_type&
          IntegerList () const;

          IntegerList_type&
          IntegerList ();

          void
          IntegerList (const IntegerList_type& x);

          void
          IntegerList (::std::unique_ptr< IntegerList_type > p);



          IntegerArray ();

          IntegerArray (const IntegerList_type&);

          IntegerArray (::std::unique_ptr< IntegerList_type >);

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

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

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

          IntegerArray&
          operator= (const IntegerArray& x);


          virtual 
          ~IntegerArray ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< IntegerList_type > IntegerList_;

          //@endcond
        };

        class BIOGEARS_CDM_API DoubleArray: public ::xml_schema::type
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::DoubleList DoubleList_type;

          typedef ::xsd::cxx::tree::traits< DoubleList_type, char > DoubleList_traits;

          const DoubleList_type&
          DoubleList () const;

          DoubleList_type&
          DoubleList ();

          void
          DoubleList (const DoubleList_type& x);

          void
          DoubleList (::std::unique_ptr< DoubleList_type > p);



          DoubleArray ();

          DoubleArray (const DoubleList_type&);

          DoubleArray (::std::unique_ptr< DoubleList_type >);

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

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

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

          DoubleArray&
          operator= (const DoubleArray& x);


          virtual 
          ~DoubleArray ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< DoubleList_type > DoubleList_;

          //@endcond
        };

        class BIOGEARS_CDM_API enumSide: public ::xml_schema::string
        {
          public:

          enum value
          {
            Left,
            Right
          };

          enumSide ();

          enumSide (value v);

          enumSide (const char* v);

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

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

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

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

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

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

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

          enumSide&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumSide_convert () const;

          public:
          static const char* const _xsd_enumSide_literals_[2];
          static const value _xsd_enumSide_indexes_[2];

          //@endcond
        };

        class BIOGEARS_CDM_API enumOpenClosed: public ::xml_schema::string
        {
          public:

          enum value
          {
            Closed,
            Open
          };

          enumOpenClosed ();

          enumOpenClosed (value v);

          enumOpenClosed (const char* v);

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

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

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

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

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

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

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

          enumOpenClosed&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumOpenClosed_convert () const;

          public:
          static const char* const _xsd_enumOpenClosed_literals_[2];
          static const value _xsd_enumOpenClosed_indexes_[2];

          //@endcond
        };

        class BIOGEARS_CDM_API enumOnOff: public ::xml_schema::string
        {
          public:

          enum value
          {
            Off,
            On
          };

          enumOnOff ();

          enumOnOff (value v);

          enumOnOff (const char* v);

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

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

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

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

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

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

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

          enumOnOff&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumOnOff_convert () const;

          public:
          static const char* const _xsd_enumOnOff_literals_[2];
          static const value _xsd_enumOnOff_indexes_[2];

          //@endcond
        };

        class BIOGEARS_CDM_API enumErrorType: public ::xml_schema::string
        {
          public:

          enum value
          {
            Standard
          };

          enumErrorType ();

          enumErrorType (value v);

          enumErrorType (const char* v);

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

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

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

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

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

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

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

          enumErrorType&
          operator= (value v);

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

          //@cond

          protected:
          value
          _xsd_enumErrorType_convert () const;

          public:
          static const char* const _xsd_enumErrorType_literals_[1];
          static const value _xsd_enumErrorType_indexes_[1];

          //@endcond
        };

        class BIOGEARS_CDM_API ErrorData: public ::xml_schema::type
        {
          public:

          typedef ::xml_schema::double_ value_type;

          typedef ::xsd::cxx::tree::traits< value_type, char, ::xsd::cxx::tree::schema_type::double_ > value_traits;

          const value_type&
          value () const;

          value_type&
          value ();

          void
          value (const value_type& x);



          typedef ::mil::tatrc::physiology::datamodel::enumErrorType type_type;

          typedef ::xsd::cxx::tree::traits< type_type, char > type_traits;

          const type_type&
          type () const;

          type_type&
          type ();

          void
          type (const type_type& x);

          void
          type (::std::unique_ptr< type_type > p);



          ErrorData ();

          ErrorData (const value_type&,
                     const type_type&);

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

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

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

          ErrorData&
          operator= (const ErrorData& x);


          virtual 
          ~ErrorData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< value_type > value_;
          ::xsd::cxx::tree::one< type_type > type_;

          //@endcond
        };

        class BIOGEARS_CDM_API ErrorList: public ::xml_schema::type
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::DoubleArray Value_type;

          typedef ::xsd::cxx::tree::traits< Value_type, char > Value_traits;

          const Value_type&
          Value () const;

          Value_type&
          Value ();

          void
          Value (const Value_type& x);

          void
          Value (::std::unique_ptr< Value_type > p);



          typedef ::mil::tatrc::physiology::datamodel::enumErrorType type_type;

          typedef ::xsd::cxx::tree::traits< type_type, char > type_traits;

          const type_type&
          type () const;

          type_type&
          type ();

          void
          type (const type_type& x);

          void
          type (::std::unique_ptr< type_type > p);



          ErrorList ();

          ErrorList (const Value_type&,
                     const type_type&);

          ErrorList (::std::unique_ptr< Value_type >,
                     const type_type&);

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

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

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

          ErrorList&
          operator= (const ErrorList& x);


          virtual 
          ~ErrorList ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Value_type > Value_;
          ::xsd::cxx::tree::one< type_type > type_;

          //@endcond
        };

        class BIOGEARS_CDM_API RunningAverageData: public ::mil::tatrc::physiology::datamodel::PropertyData
        {
          public:

          typedef ::xml_schema::double_ sum_type;

          typedef ::xsd::cxx::tree::traits< sum_type, char, ::xsd::cxx::tree::schema_type::double_ > sum_traits;

          const sum_type&
          sum () const;

          sum_type&
          sum ();

          void
          sum (const sum_type& x);



          typedef ::xml_schema::unsigned_int numSamples_type;

          typedef ::xsd::cxx::tree::traits< numSamples_type, char > numSamples_traits;

          const numSamples_type&
          numSamples () const;

          numSamples_type&
          numSamples ();

          void
          numSamples (const numSamples_type& x);



          RunningAverageData ();

          RunningAverageData (const sum_type&,
                              const numSamples_type&);

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

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

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

          RunningAverageData&
          operator= (const RunningAverageData& x);


          virtual 
          ~RunningAverageData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< sum_type > sum_;
          ::xsd::cxx::tree::one< numSamples_type > numSamples_;

          //@endcond
        };

        class BIOGEARS_CDM_API ScalarData: public ::mil::tatrc::physiology::datamodel::PropertyData
        {
          public:

          typedef ::xml_schema::double_ value_type;

          typedef ::xsd::cxx::tree::traits< value_type, char, ::xsd::cxx::tree::schema_type::double_ > value_traits;

          const value_type&
          value () const;

          value_type&
          value ();

          void
          value (const value_type& x);



          typedef ::xml_schema::string unit_type;

          typedef ::xsd::cxx::tree::optional< unit_type > unit_optional;

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

          const unit_optional&
          unit () const;

          unit_optional&
          unit ();

          void
          unit (const unit_type& x);

          void
          unit (const unit_optional& x);

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



          typedef ::xml_schema::boolean readOnly_type;

          typedef ::xsd::cxx::tree::traits< readOnly_type, char > readOnly_traits;

          const readOnly_type&
          readOnly () const;

          readOnly_type&
          readOnly ();

          void
          readOnly (const readOnly_type& x);

          static readOnly_type
          readOnly_default_value ();



          ScalarData ();

          ScalarData (const value_type&);

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

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

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

          ScalarData&
          operator= (const ScalarData& x);


          virtual 
          ~ScalarData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< value_type > value_;
          unit_optional unit_;
          ::xsd::cxx::tree::one< readOnly_type > readOnly_;

          //@endcond
        };

        class BIOGEARS_CDM_API ScalarFractionData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarFractionData ();

          ScalarFractionData (const value_type&);

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

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

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


          virtual 
          ~ScalarFractionData ();
        };

        class BIOGEARS_CDM_API Bound0To1Double: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
        {
          public:

          Bound0To1Double ();

          Bound0To1Double (const ::xml_schema::double_&);

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

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

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

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

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


          virtual 
          ~Bound0To1Double ();
        };

        class BIOGEARS_CDM_API Scalar0To1Data: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          Scalar0To1Data ();

          Scalar0To1Data (const value_type&);

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

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

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


          virtual 
          ~Scalar0To1Data ();
        };

        class BIOGEARS_CDM_API BoundNeg1To1Double: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::double_, char, ::xml_schema::simple_type, ::xsd::cxx::tree::schema_type::double_ >
        {
          public:

          BoundNeg1To1Double ();

          BoundNeg1To1Double (const ::xml_schema::double_&);

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

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

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

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

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


          virtual 
          ~BoundNeg1To1Double ();
        };

        class BIOGEARS_CDM_API ScalarNeg1To1Data: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarNeg1To1Data ();

          ScalarNeg1To1Data (const value_type&);

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

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

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


          virtual 
          ~ScalarNeg1To1Data ();
        };

        class BIOGEARS_CDM_API ScalarAmountData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarAmountData ();

          ScalarAmountData (const value_type&);

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

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

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


          virtual 
          ~ScalarAmountData ();
        };

        class BIOGEARS_CDM_API ScalarAmountPerMassData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarAmountPerMassData ();

          ScalarAmountPerMassData (const value_type&);

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

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

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


          virtual 
          ~ScalarAmountPerMassData ();
        };

        class BIOGEARS_CDM_API ScalarAmountPerTimeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarAmountPerTimeData ();

          ScalarAmountPerTimeData (const value_type&);

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

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

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


          virtual 
          ~ScalarAmountPerTimeData ();
        };

        class BIOGEARS_CDM_API ScalarAmountPerVolumeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarAmountPerVolumeData ();

          ScalarAmountPerVolumeData (const value_type&);

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

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

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


          virtual 
          ~ScalarAmountPerVolumeData ();
        };

        class BIOGEARS_CDM_API ScalarAreaData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarAreaData ();

          ScalarAreaData (const value_type&);

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

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

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


          virtual 
          ~ScalarAreaData ();
        };

        class BIOGEARS_CDM_API ScalarAreaPerTimePressureData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarAreaPerTimePressureData ();

          ScalarAreaPerTimePressureData (const value_type&);

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

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

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


          virtual 
          ~ScalarAreaPerTimePressureData ();
        };

        class BIOGEARS_CDM_API ScalarElectricCapacitanceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarElectricCapacitanceData ();

          ScalarElectricCapacitanceData (const value_type&);

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

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

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


          virtual 
          ~ScalarElectricCapacitanceData ();
        };

        class BIOGEARS_CDM_API ScalarElectricChargeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarElectricChargeData ();

          ScalarElectricChargeData (const value_type&);

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

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

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


          virtual 
          ~ScalarElectricChargeData ();
        };

        class BIOGEARS_CDM_API ScalarElectricCurrentData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarElectricCurrentData ();

          ScalarElectricCurrentData (const value_type&);

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

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

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


          virtual 
          ~ScalarElectricCurrentData ();
        };

        class BIOGEARS_CDM_API ScalarElectricPotentialData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarElectricPotentialData ();

          ScalarElectricPotentialData (const value_type&);

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

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

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


          virtual 
          ~ScalarElectricPotentialData ();
        };

        class BIOGEARS_CDM_API ScalarElectricInductanceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarElectricInductanceData ();

          ScalarElectricInductanceData (const value_type&);

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

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

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


          virtual 
          ~ScalarElectricInductanceData ();
        };

        class BIOGEARS_CDM_API ScalarElectricResistanceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarElectricResistanceData ();

          ScalarElectricResistanceData (const value_type&);

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

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

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


          virtual 
          ~ScalarElectricResistanceData ();
        };

        class BIOGEARS_CDM_API ScalarEnergyData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarEnergyData ();

          ScalarEnergyData (const value_type&);

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

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

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


          virtual 
          ~ScalarEnergyData ();
        };

        class BIOGEARS_CDM_API ScalarEnergyPerAmountData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarEnergyPerAmountData ();

          ScalarEnergyPerAmountData (const value_type&);

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

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

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


          virtual 
          ~ScalarEnergyPerAmountData ();
        };

        class BIOGEARS_CDM_API ScalarEnergyPerMassData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarEnergyPerMassData ();

          ScalarEnergyPerMassData (const value_type&);

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

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

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


          virtual 
          ~ScalarEnergyPerMassData ();
        };

        class BIOGEARS_CDM_API ScalarFlowResistanceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarFlowResistanceData ();

          ScalarFlowResistanceData (const value_type&);

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

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

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


          virtual 
          ~ScalarFlowResistanceData ();
        };

        class BIOGEARS_CDM_API ScalarFlowComplianceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarFlowComplianceData ();

          ScalarFlowComplianceData (const value_type&);

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

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

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


          virtual 
          ~ScalarFlowComplianceData ();
        };

        class BIOGEARS_CDM_API ScalarFlowElastanceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarFlowElastanceData ();

          ScalarFlowElastanceData (const value_type&);

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

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

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


          virtual 
          ~ScalarFlowElastanceData ();
        };

        class BIOGEARS_CDM_API ScalarFlowInertanceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarFlowInertanceData ();

          ScalarFlowInertanceData (const value_type&);

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

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

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


          virtual 
          ~ScalarFlowInertanceData ();
        };

        class BIOGEARS_CDM_API ScalarForceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarForceData ();

          ScalarForceData (const value_type&);

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

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

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


          virtual 
          ~ScalarForceData ();
        };

        class BIOGEARS_CDM_API ScalarFrequencyData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarFrequencyData ();

          ScalarFrequencyData (const value_type&);

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

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

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


          virtual 
          ~ScalarFrequencyData ();
        };

        class BIOGEARS_CDM_API ScalarHeatCapacitanceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarHeatCapacitanceData ();

          ScalarHeatCapacitanceData (const value_type&);

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

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

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


          virtual 
          ~ScalarHeatCapacitanceData ();
        };

        class BIOGEARS_CDM_API ScalarHeatCapacitancePerAmountData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarHeatCapacitancePerAmountData ();

          ScalarHeatCapacitancePerAmountData (const value_type&);

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

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

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


          virtual 
          ~ScalarHeatCapacitancePerAmountData ();
        };

        class BIOGEARS_CDM_API ScalarHeatCapacitancePerMassData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarHeatCapacitancePerMassData ();

          ScalarHeatCapacitancePerMassData (const value_type&);

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

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

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


          virtual 
          ~ScalarHeatCapacitancePerMassData ();
        };

        class BIOGEARS_CDM_API ScalarHeatConductanceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarHeatConductanceData ();

          ScalarHeatConductanceData (const value_type&);

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

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

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


          virtual 
          ~ScalarHeatConductanceData ();
        };

        class BIOGEARS_CDM_API ScalarHeatConductancePerAreaData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarHeatConductancePerAreaData ();

          ScalarHeatConductancePerAreaData (const value_type&);

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

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

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


          virtual 
          ~ScalarHeatConductancePerAreaData ();
        };

        class BIOGEARS_CDM_API ScalarHeatInductanceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarHeatInductanceData ();

          ScalarHeatInductanceData (const value_type&);

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

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

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


          virtual 
          ~ScalarHeatInductanceData ();
        };

        class BIOGEARS_CDM_API ScalarHeatResistanceData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarHeatResistanceData ();

          ScalarHeatResistanceData (const value_type&);

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

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

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


          virtual 
          ~ScalarHeatResistanceData ();
        };

        class BIOGEARS_CDM_API ScalarHeatResistanceAreaData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarHeatResistanceAreaData ();

          ScalarHeatResistanceAreaData (const value_type&);

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

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

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


          virtual 
          ~ScalarHeatResistanceAreaData ();
        };

        class BIOGEARS_CDM_API ScalarInversePressureData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarInversePressureData ();

          ScalarInversePressureData (const value_type&);

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

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

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


          virtual 
          ~ScalarInversePressureData ();
        };

        class BIOGEARS_CDM_API ScalarInverseVolumeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarInverseVolumeData ();

          ScalarInverseVolumeData (const value_type&);

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

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

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


          virtual 
          ~ScalarInverseVolumeData ();
        };

        class BIOGEARS_CDM_API ScalarLengthData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarLengthData ();

          ScalarLengthData (const value_type&);

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

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

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


          virtual 
          ~ScalarLengthData ();
        };

        class BIOGEARS_CDM_API ScalarLengthPerTimeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarLengthPerTimeData ();

          ScalarLengthPerTimeData (const value_type&);

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

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

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


          virtual 
          ~ScalarLengthPerTimeData ();
        };

        class BIOGEARS_CDM_API ScalarLengthPerTimePressureData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarLengthPerTimePressureData ();

          ScalarLengthPerTimePressureData (const value_type&);

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

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

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


          virtual 
          ~ScalarLengthPerTimePressureData ();
        };

        class BIOGEARS_CDM_API ScalarMassData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarMassData ();

          ScalarMassData (const value_type&);

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

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

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


          virtual 
          ~ScalarMassData ();
        };

        class BIOGEARS_CDM_API ScalarMassPerAmountData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarMassPerAmountData ();

          ScalarMassPerAmountData (const value_type&);

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

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

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


          virtual 
          ~ScalarMassPerAmountData ();
        };

        class BIOGEARS_CDM_API ScalarMassPerAreaTimeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarMassPerAreaTimeData ();

          ScalarMassPerAreaTimeData (const value_type&);

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

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

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


          virtual 
          ~ScalarMassPerAreaTimeData ();
        };

        class BIOGEARS_CDM_API ScalarMassPerMassData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarMassPerMassData ();

          ScalarMassPerMassData (const value_type&);

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

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

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


          virtual 
          ~ScalarMassPerMassData ();
        };

        class BIOGEARS_CDM_API ScalarMassPerTimeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarMassPerTimeData ();

          ScalarMassPerTimeData (const value_type&);

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

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

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


          virtual 
          ~ScalarMassPerTimeData ();
        };

        class BIOGEARS_CDM_API ScalarMassPerVolumeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarMassPerVolumeData ();

          ScalarMassPerVolumeData (const value_type&);

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

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

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


          virtual 
          ~ScalarMassPerVolumeData ();
        };

        class BIOGEARS_CDM_API ScalarTimeMassPerVolumeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarTimeMassPerVolumeData ();

          ScalarTimeMassPerVolumeData (const value_type&);

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

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

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


          virtual 
          ~ScalarTimeMassPerVolumeData ();
        };

        class BIOGEARS_CDM_API ScalarOsmolalityData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarOsmolalityData ();

          ScalarOsmolalityData (const value_type&);

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

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

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


          virtual 
          ~ScalarOsmolalityData ();
        };

        class BIOGEARS_CDM_API ScalarOsmolarityData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarOsmolarityData ();

          ScalarOsmolarityData (const value_type&);

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

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

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


          virtual 
          ~ScalarOsmolarityData ();
        };

        class BIOGEARS_CDM_API ScalarPowerData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarPowerData ();

          ScalarPowerData (const value_type&);

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

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

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


          virtual 
          ~ScalarPowerData ();
        };

        class BIOGEARS_CDM_API ScalarPowerPerAreaTemperatureToTheFourthData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarPowerPerAreaTemperatureToTheFourthData ();

          ScalarPowerPerAreaTemperatureToTheFourthData (const value_type&);

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

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

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


          virtual 
          ~ScalarPowerPerAreaTemperatureToTheFourthData ();
        };

        class BIOGEARS_CDM_API ScalarPressureData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarPressureData ();

          ScalarPressureData (const value_type&);

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

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

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


          virtual 
          ~ScalarPressureData ();
        };

        class BIOGEARS_CDM_API ScalarPressurePerVolumeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarPressurePerVolumeData ();

          ScalarPressurePerVolumeData (const value_type&);

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

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

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


          virtual 
          ~ScalarPressurePerVolumeData ();
        };

        class BIOGEARS_CDM_API ScalarPressureTimePerVolumeAreaData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarPressureTimePerVolumeAreaData ();

          ScalarPressureTimePerVolumeAreaData (const value_type&);

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

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

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


          virtual 
          ~ScalarPressureTimePerVolumeAreaData ();
        };

        class BIOGEARS_CDM_API ScalarPressureTimePerAreaData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarPressureTimePerAreaData ();

          ScalarPressureTimePerAreaData (const value_type&);

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

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

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


          virtual 
          ~ScalarPressureTimePerAreaData ();
        };

        class BIOGEARS_CDM_API ScalarTimeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarTimeData ();

          ScalarTimeData (const value_type&);

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

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

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


          virtual 
          ~ScalarTimeData ();
        };

        class BIOGEARS_CDM_API ScalarTemperatureData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarTemperatureData ();

          ScalarTemperatureData (const value_type&);

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

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

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


          virtual 
          ~ScalarTemperatureData ();
        };

        class BIOGEARS_CDM_API ScalarVolumeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarVolumeData ();

          ScalarVolumeData (const value_type&);

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

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

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


          virtual 
          ~ScalarVolumeData ();
        };

        class BIOGEARS_CDM_API ScalarVolumePerTimeData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarVolumePerTimeData ();

          ScalarVolumePerTimeData (const value_type&);

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

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

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


          virtual 
          ~ScalarVolumePerTimeData ();
        };

        class BIOGEARS_CDM_API ScalarVolumePerPressureData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarVolumePerPressureData ();

          ScalarVolumePerPressureData (const value_type&);

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

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

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


          virtual 
          ~ScalarVolumePerPressureData ();
        };

        class BIOGEARS_CDM_API ScalarVolumePerTimeAreaData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarVolumePerTimeAreaData ();

          ScalarVolumePerTimeAreaData (const value_type&);

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

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

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


          virtual 
          ~ScalarVolumePerTimeAreaData ();
        };

        class BIOGEARS_CDM_API ScalarVolumePerTimeMassData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarVolumePerTimeMassData ();

          ScalarVolumePerTimeMassData (const value_type&);

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

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

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


          virtual 
          ~ScalarVolumePerTimeMassData ();
        };

        class BIOGEARS_CDM_API ScalarVolumePerTimePressureData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarVolumePerTimePressureData ();

          ScalarVolumePerTimePressureData (const value_type&);

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

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

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


          virtual 
          ~ScalarVolumePerTimePressureData ();
        };

        class BIOGEARS_CDM_API ScalarVolumePerTimePressureAreaData: public ::mil::tatrc::physiology::datamodel::ScalarData
        {
          public:

          ScalarVolumePerTimePressureAreaData ();

          ScalarVolumePerTimePressureAreaData (const value_type&);

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

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

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


          virtual 
          ~ScalarVolumePerTimePressureAreaData ();
        };

        class BIOGEARS_CDM_API ArrayData: public ::mil::tatrc::physiology::datamodel::PropertyData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::DoubleArray Value_type;

          typedef ::xsd::cxx::tree::traits< Value_type, char > Value_traits;

          const Value_type&
          Value () const;

          Value_type&
          Value ();

          void
          Value (const Value_type& x);

          void
          Value (::std::unique_ptr< Value_type > p);



          typedef ::xml_schema::string unit_type;

          typedef ::xsd::cxx::tree::optional< unit_type > unit_optional;

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

          const unit_optional&
          unit () const;

          unit_optional&
          unit ();

          void
          unit (const unit_type& x);

          void
          unit (const unit_optional& x);

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



          ArrayData ();

          ArrayData (const Value_type&);

          ArrayData (::std::unique_ptr< Value_type >);

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

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

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

          ArrayData&
          operator= (const ArrayData& x);


          virtual 
          ~ArrayData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Value_type > Value_;
          unit_optional unit_;

          //@endcond
        };

        class BIOGEARS_CDM_API ArrayTimeData: public ::mil::tatrc::physiology::datamodel::ArrayData
        {
          public:

          ArrayTimeData ();

          ArrayTimeData (const Value_type&);

          ArrayTimeData (::std::unique_ptr< Value_type >);

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

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

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


          virtual 
          ~ArrayTimeData ();
        };

        class BIOGEARS_CDM_API FunctionData: public ::mil::tatrc::physiology::datamodel::PropertyData
        {
          public:

          typedef ::mil::tatrc::physiology::datamodel::DoubleArray Dependent_type;

          typedef ::xsd::cxx::tree::traits< Dependent_type, char > Dependent_traits;

          const Dependent_type&
          Dependent () const;

          Dependent_type&
          Dependent ();

          void
          Dependent (const Dependent_type& x);

          void
          Dependent (::std::unique_ptr< Dependent_type > p);



          typedef ::mil::tatrc::physiology::datamodel::DoubleArray Independent_type;

          typedef ::xsd::cxx::tree::traits< Independent_type, char > Independent_traits;

          const Independent_type&
          Independent () const;

          Independent_type&
          Independent ();

          void
          Independent (const Independent_type& x);

          void
          Independent (::std::unique_ptr< Independent_type > p);



          typedef ::xml_schema::string DependentUnit_type;

          typedef ::xsd::cxx::tree::optional< DependentUnit_type > DependentUnit_optional;

          typedef ::xsd::cxx::tree::traits< DependentUnit_type, char > DependentUnit_traits;

          const DependentUnit_optional&
          DependentUnit () const;

          DependentUnit_optional&
          DependentUnit ();

          void
          DependentUnit (const DependentUnit_type& x);

          void
          DependentUnit (const DependentUnit_optional& x);

          void
          DependentUnit (::std::unique_ptr< DependentUnit_type > p);



          typedef ::xml_schema::string IndependentUnit_type;

          typedef ::xsd::cxx::tree::optional< IndependentUnit_type > IndependentUnit_optional;

          typedef ::xsd::cxx::tree::traits< IndependentUnit_type, char > IndependentUnit_traits;

          const IndependentUnit_optional&
          IndependentUnit () const;

          IndependentUnit_optional&
          IndependentUnit ();

          void
          IndependentUnit (const IndependentUnit_type& x);

          void
          IndependentUnit (const IndependentUnit_optional& x);

          void
          IndependentUnit (::std::unique_ptr< IndependentUnit_type > p);



          FunctionData ();

          FunctionData (const Dependent_type&,
                        const Independent_type&);

          FunctionData (::std::unique_ptr< Dependent_type >,
                        ::std::unique_ptr< Independent_type >);

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

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

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

          FunctionData&
          operator= (const FunctionData& x);


          virtual 
          ~FunctionData ();

          // Implementation.
          //

          //@cond

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

          protected:
          ::xsd::cxx::tree::one< Dependent_type > Dependent_;
          ::xsd::cxx::tree::one< Independent_type > Independent_;
          DependentUnit_optional DependentUnit_;
          IndependentUnit_optional IndependentUnit_;

          //@endcond
        };

        class BIOGEARS_CDM_API FunctionVolumeVsTimeData: public ::mil::tatrc::physiology::datamodel::FunctionData
        {
          public:

          FunctionVolumeVsTimeData ();

          FunctionVolumeVsTimeData (const Dependent_type&,
                                    const Independent_type&);

          FunctionVolumeVsTimeData (::std::unique_ptr< Dependent_type >,
                                    ::std::unique_ptr< Independent_type >);

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

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

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


          virtual 
          ~FunctionVolumeVsTimeData ();
        };

        class BIOGEARS_CDM_API FunctionElectricPotentialVsTimeData: public ::mil::tatrc::physiology::datamodel::FunctionData
        {
          public:

          FunctionElectricPotentialVsTimeData ();

          FunctionElectricPotentialVsTimeData (const Dependent_type&,
                                               const Independent_type&);

          FunctionElectricPotentialVsTimeData (::std::unique_ptr< Dependent_type >,
                                               ::std::unique_ptr< Independent_type >);

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

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

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


          virtual 
          ~FunctionElectricPotentialVsTimeData ();
        };

        class BIOGEARS_CDM_API HistogramData: public ::mil::tatrc::physiology::datamodel::FunctionData
        {
          public:

          HistogramData ();

          HistogramData (const Dependent_type&,
                         const Independent_type&);

          HistogramData (::std::unique_ptr< Dependent_type >,
                         ::std::unique_ptr< Independent_type >);

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

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

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


          virtual 
          ~HistogramData ();
        };

        class BIOGEARS_CDM_API HistogramFractionVsLengthData: public ::mil::tatrc::physiology::datamodel::HistogramData
        {
          public:

          HistogramFractionVsLengthData ();

          HistogramFractionVsLengthData (const Dependent_type&,
                                         const Independent_type&);

          HistogramFractionVsLengthData (::std::unique_ptr< Dependent_type >,
                                         ::std::unique_ptr< Independent_type >);

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

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

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


          virtual 
          ~HistogramFractionVsLengthData ();
        };

        class BIOGEARS_CDM_API IntegerList: public ::xml_schema::simple_type,
          public ::xsd::cxx::tree::list< ::xml_schema::int_, char >
        {
          public:
          IntegerList ();

          IntegerList (size_type n, const ::xml_schema::int_& x);

          template < typename I >
          IntegerList (const I& begin, const I& end)
          : ::xsd::cxx::tree::list< ::xml_schema::int_, char > (begin, end, this)
          {
          }

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

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

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

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

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

          virtual 
          ~IntegerList ();
        };

        class BIOGEARS_CDM_API DoubleList: public ::xml_schema::simple_type,
          public ::xsd::cxx::tree::list< ::xml_schema::double_, char, ::xsd::cxx::tree::schema_type::double_ >
        {
          public:
          DoubleList ();

          DoubleList (size_type n, const ::xml_schema::double_& x);

          template < typename I >
          DoubleList (const I& begin, const I& end)
          : ::xsd::cxx::tree::list< ::xml_schema::double_, char, ::xsd::cxx::tree::schema_type::double_ > (begin, end, this)
          {
          }

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

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

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

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

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

          virtual 
          ~DoubleList ();
        };
      }
    }
  }
}

#include <iosfwd>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#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
      {
      }
    }
  }
}

#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 PropertyData&);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#include <xsd/cxx/post.hxx>

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

#endif // D__BIOGEARS_CORE_SHARE_XSD__CDM_PROPERTIES_HXX