SimulationXSD.h

Go to the documentation of this file.

// Copyright (c) 2005-2023 Code Synthesis.
//
// 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 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 makes a special exception for the Free/Libre
// and Open Source Software (FLOSS) which is described in the accompanying
// FLOSSE file.
//
 
#ifndef SIMULATION_XSD_H
#define SIMULATION_XSD_H
 
#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.
//
//
// End prologue.
 
#include <xsd/cxx/config.hxx>
 
#include <xsd/cxx/pre.hxx>
 
#include <xsd/cxx/xml/char-utf8.hxx>
 
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/exceptions.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/boolean.hxx>
#include <xsd/cxx/tree/parsing/byte.hxx>
#include <xsd/cxx/tree/parsing/decimal.hxx>
#include <xsd/cxx/tree/parsing/double.hxx>
#include <xsd/cxx/tree/parsing/float.hxx>
#include <xsd/cxx/tree/parsing/int.hxx>
#include <xsd/cxx/tree/parsing/long.hxx>
#include <xsd/cxx/tree/parsing/short.hxx>
#include <xsd/cxx/tree/parsing/unsigned-byte.hxx>
#include <xsd/cxx/tree/parsing/unsigned-int.hxx>
#include <xsd/cxx/tree/parsing/unsigned-long.hxx>
#include <xsd/cxx/tree/parsing/unsigned-short.hxx>
 
#include <xsd/cxx/tree/serialization.hxx>
#include <xsd/cxx/tree/serialization/boolean.hxx>
#include <xsd/cxx/tree/serialization/byte.hxx>
#include <xsd/cxx/tree/serialization/decimal.hxx>
#include <xsd/cxx/tree/serialization/double.hxx>
#include <xsd/cxx/tree/serialization/float.hxx>
#include <xsd/cxx/tree/serialization/int.hxx>
#include <xsd/cxx/tree/serialization/long.hxx>
#include <xsd/cxx/tree/serialization/short.hxx>
#include <xsd/cxx/tree/serialization/unsigned-byte.hxx>
#include <xsd/cxx/tree/serialization/unsigned-int.hxx>
#include <xsd/cxx/tree/serialization/unsigned-long.hxx>
#include <xsd/cxx/tree/serialization/unsigned-short.hxx>
#include <xsd/cxx/xml/dom/serialization-header.hxx>
 
namespace xml_schema {
// anyType and anySimpleType.
//
 
typedef ::xsd::cxx::tree::type Type;
 
typedef ::xsd::cxx::tree::simple_type<char, Type> SimpleType;
 
typedef ::xsd::cxx::tree::type Container;
 
// 8-bit
//
 
typedef signed char Byte;
 
typedef unsigned char UnsignedByte;
 
// 16-bit
//
 
typedef short Short;
 
typedef unsigned short UnsignedShort;
 
// 32-bit
//
 
typedef int Int;
 
typedef unsigned int UnsignedInt;
 
// 64-bit
//
 
typedef long long Long;
 
typedef unsigned long long UnsignedLong;
 
// Supposed to be arbitrary-length integral types.
//
 
typedef long long Integer;
 
typedef long long NonPositiveInteger;
 
typedef unsigned long long NonNegativeInteger;
 
typedef unsigned long long PositiveInteger;
 
typedef long long NegativeInteger;
 
// Boolean.
//
 
typedef bool Boolean;
 
// Floating-point types.
//
 
typedef float Float;
 
typedef double Double;
 
typedef double Decimal;
 
// String types.
//
 
typedef ::xsd::cxx::tree::string<char, SimpleType> String;
 
typedef ::xsd::cxx::tree::normalized_string<char, String> NormalizedString;
 
typedef ::xsd::cxx::tree::token<char, NormalizedString> Token;
 
typedef ::xsd::cxx::tree::name<char, Token> Name;
 
typedef ::xsd::cxx::tree::nmtoken<char, Token> Nmtoken;
 
typedef ::xsd::cxx::tree::nmtokens<char, SimpleType, 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, SimpleType, Idref> Idrefs;
 
// URI.
//
 
typedef ::xsd::cxx::tree::uri<char, SimpleType> Uri;
 
// Qualified name.
//
 
typedef ::xsd::cxx::tree::qname<char, SimpleType, Uri, Ncname> Qname;
 
// Binary.
//
 
typedef ::xsd::cxx::tree::buffer<char> Buffer;
 
typedef ::xsd::cxx::tree::base64_binary<char, SimpleType> Base64Binary;
 
typedef ::xsd::cxx::tree::hex_binary<char, SimpleType> HexBinary;
 
// Date/time.
//
 
typedef ::xsd::cxx::tree::time_zone TimeZone;
 
typedef ::xsd::cxx::tree::date<char, SimpleType> Date;
 
typedef ::xsd::cxx::tree::date_time<char, SimpleType> DateTime;
 
typedef ::xsd::cxx::tree::duration<char, SimpleType> Duration;
 
typedef ::xsd::cxx::tree::gday<char, SimpleType> Gday;
 
typedef ::xsd::cxx::tree::gmonth<char, SimpleType> Gmonth;
 
typedef ::xsd::cxx::tree::gmonth_day<char, SimpleType> GmonthDay;
 
typedef ::xsd::cxx::tree::gyear<char, SimpleType> Gyear;
 
typedef ::xsd::cxx::tree::gyear_month<char, SimpleType> GyearMonth;
 
typedef ::xsd::cxx::tree::time<char, SimpleType> Time;
 
// Entity.
//
 
typedef ::xsd::cxx::tree::entity<char, Ncname> Entity;
 
typedef ::xsd::cxx::tree::entities<char, SimpleType, Entity> Entities;
 
typedef ::xsd::cxx::tree::content_order ContentOrder;
// Namespace information and list stream. Used in
// serialization functions.
//
typedef ::xsd::cxx::xml::dom::namespace_info<char> NamespaceInfo;
 
typedef ::xsd::cxx::xml::dom::namespace_infomap<char> NamespaceInfomap;
 
typedef ::xsd::cxx::tree::list_stream<char> ListStream;
 
typedef ::xsd::cxx::tree::as_double<Double> AsDouble;
 
typedef ::xsd::cxx::tree::as_decimal<Decimal> AsDecimal;
 
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> DuplicateId;
 
typedef ::xsd::cxx::tree::parsing<char> Parsing;
 
typedef ::xsd::cxx::tree::expected_element<char> ExpectedElement;
 
typedef ::xsd::cxx::tree::unexpected_element<char> UnexpectedElement;
 
typedef ::xsd::cxx::tree::expected_attribute<char> ExpectedAttribute;
 
typedef ::xsd::cxx::tree::unexpected_enumerator<char> UnexpectedEnumerator;
 
typedef ::xsd::cxx::tree::expected_text_content<char> ExpectedTextContent;
 
typedef ::xsd::cxx::tree::no_prefix_mapping<char> NoPrefixMapping;
 
typedef ::xsd::cxx::tree::serialization<char> Serialization;
 
typedef ::xsd::cxx::xml::error_handler<char> ErrorHandler;
 
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 treeNodeKey = ::xsd::cxx::tree::user_data_keys::node;
#endif
} // namespace dom
} // namespace xml_schema
 
// Forward declarations.
//
class ArgsType;
class ParallelType;
class BdConditionsType;
class BoundaryConditionType;
class PositionType;
class VelocityType;
class ForceType;
class SizeType;
class CuboidType;
class ParticleType;
class DiscType;
class ObjectsType;
class SpecialCaseType;
class MembraneType;
class AnalyzerType;
class SimType;
class ThermostatType;
 
#include <algorithm> // std::binary_search
#include <limits>    // std::numeric_limits
#include <memory>    // ::std::unique_ptr
#include <utility>   // std::move
 
#include <xsd/cxx/xml/char-utf8.hxx>
 
#include <xsd/cxx/tree/containers.hxx>
#include <xsd/cxx/tree/elements.hxx>
#include <xsd/cxx/tree/exceptions.hxx>
#include <xsd/cxx/tree/list.hxx>
 
#include <xsd/cxx/xml/dom/parsing-header.hxx>
 
class ArgsType : public ::xml_schema::Type {
  public:
 
    typedef ::xml_schema::Double StartTimeType;
 
    typedef ::xsd::cxx::tree::optional<StartTimeType> StartTimeOptional;
 
    typedef ::xsd::cxx::tree::traits<StartTimeType, char, ::xsd::cxx::tree::schema_type::double_> StartTimeTraits;
 
    const StartTimeOptional &startTime() const;
 
    StartTimeOptional &startTime();
 
    void startTime(const StartTimeType &x);
 
    void startTime(const StartTimeOptional &x);
 
 
 
    typedef ::xml_schema::Double EndTimeType;
 
    typedef ::xsd::cxx::tree::optional<EndTimeType> EndTimeOptional;
 
    typedef ::xsd::cxx::tree::traits<EndTimeType, char, ::xsd::cxx::tree::schema_type::double_> EndTimeTraits;
 
    const EndTimeOptional &endTime() const;
 
    EndTimeOptional &endTime();
 
    void endTime(const EndTimeType &x);
 
    void endTime(const EndTimeOptional &x);
 
 
 
    typedef ::xml_schema::Double Delta_tType;
 
    typedef ::xsd::cxx::tree::optional<Delta_tType> Delta_tOptional;
 
    typedef ::xsd::cxx::tree::traits<Delta_tType, char, ::xsd::cxx::tree::schema_type::double_> Delta_tTraits;
 
    const Delta_tOptional &delta_t() const;
 
    Delta_tOptional &delta_t();
 
    void delta_t(const Delta_tType &x);
 
    void delta_t(const Delta_tOptional &x);
 
 
 
    typedef ::xml_schema::Int FrequencyType;
 
    typedef ::xsd::cxx::tree::optional<FrequencyType> FrequencyOptional;
 
    typedef ::xsd::cxx::tree::traits<FrequencyType, char> FrequencyTraits;
 
    const FrequencyOptional &frequency() const;
 
    FrequencyOptional &frequency();
 
    void frequency(const FrequencyType &x);
 
    void frequency(const FrequencyOptional &x);
 
 
 
    typedef ::xml_schema::String BasenameType;
 
    typedef ::xsd::cxx::tree::optional<BasenameType> BasenameOptional;
 
    typedef ::xsd::cxx::tree::traits<BasenameType, char> BasenameTraits;
 
    const BasenameOptional &basename() const;
 
    BasenameOptional &basename();
 
    void basename(const BasenameType &x);
 
    void basename(const BasenameOptional &x);
 
    void basename(::std::unique_ptr<BasenameType> p);
 
 
 
    typedef ::xml_schema::String OutputType;
 
    typedef ::xsd::cxx::tree::optional<OutputType> OutputOptional;
 
    typedef ::xsd::cxx::tree::traits<OutputType, char> OutputTraits;
 
    const OutputOptional &output() const;
 
    OutputOptional &output();
 
    void output(const OutputType &x);
 
    void output(const OutputOptional &x);
 
    void output(::std::unique_ptr<OutputType> p);
 
 
 
    typedef ::SizeType DomainSizeType;
 
    typedef ::xsd::cxx::tree::optional<DomainSizeType> DomainSizeOptional;
 
    typedef ::xsd::cxx::tree::traits<DomainSizeType, char> DomainSizeTraits;
 
    const DomainSizeOptional &domainSize() const;
 
    DomainSizeOptional &domainSize();
 
    void domainSize(const DomainSizeType &x);
 
    void domainSize(const DomainSizeOptional &x);
 
    void domainSize(::std::unique_ptr<DomainSizeType> p);
 
 
 
    typedef ::xml_schema::Double CutoffRadiusType;
 
    typedef ::xsd::cxx::tree::optional<CutoffRadiusType> CutoffRadiusOptional;
 
    typedef ::xsd::cxx::tree::traits<CutoffRadiusType, char, ::xsd::cxx::tree::schema_type::double_> CutoffRadiusTraits;
 
    const CutoffRadiusOptional &cutoffRadius() const;
 
    CutoffRadiusOptional &cutoffRadius();
 
    void cutoffRadius(const CutoffRadiusType &x);
 
    void cutoffRadius(const CutoffRadiusOptional &x);
 
 
 
    typedef ::BdConditionsType BdConditionsType;
 
    typedef ::xsd::cxx::tree::optional<BdConditionsType> BdConditionsOptional;
 
    typedef ::xsd::cxx::tree::traits<BdConditionsType, char> BdConditionsTraits;
 
    const BdConditionsOptional &bdConditions() const;
 
    BdConditionsOptional &bdConditions();
 
    void bdConditions(const BdConditionsType &x);
 
    void bdConditions(const BdConditionsOptional &x);
 
    void bdConditions(::std::unique_ptr<BdConditionsType> p);
 
 
 
    typedef ::xml_schema::Double GravityType;
 
    typedef ::xsd::cxx::tree::optional<GravityType> GravityOptional;
 
    typedef ::xsd::cxx::tree::traits<GravityType, char, ::xsd::cxx::tree::schema_type::double_> GravityTraits;
 
    const GravityOptional &gravity() const;
 
    GravityOptional &gravity();
 
    void gravity(const GravityType &x);
 
    void gravity(const GravityOptional &x);
 
 
 
    typedef ::ParallelType ParallelizationType;
 
    typedef ::xsd::cxx::tree::optional<ParallelizationType> ParallelizationOptional;
 
    typedef ::xsd::cxx::tree::traits<ParallelizationType, char> ParallelizationTraits;
 
    const ParallelizationOptional &parallelization() const;
 
    ParallelizationOptional &parallelization();
 
    void parallelization(const ParallelizationType &x);
 
    void parallelization(const ParallelizationOptional &x);
 
    void parallelization(::std::unique_ptr<ParallelizationType> p);
 
 
 
    ArgsType();
 
    ArgsType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    ArgsType(const ArgsType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual ArgsType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    ArgsType &operator=(const ArgsType &x);
 
 
    virtual ~ArgsType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    StartTimeOptional startTime_;
    EndTimeOptional endTime_;
    Delta_tOptional delta_t_;
    FrequencyOptional frequency_;
    BasenameOptional basename_;
    OutputOptional output_;
    DomainSizeOptional domainSize_;
    CutoffRadiusOptional cutoffRadius_;
    BdConditionsOptional bdConditions_;
    GravityOptional gravity_;
    ParallelizationOptional parallelization_;
 
    //@endcond
};
 
class ParallelType : public ::xml_schema::String {
  public:
    enum Value { coarse, fine };
 
    ParallelType(Value v);
 
    ParallelType(const char *v);
 
    ParallelType(const ::std::string &v);
 
    ParallelType(const ::xml_schema::String &v);
 
    ParallelType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    ParallelType(const ::xercesc::DOMAttr &a, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    ParallelType(const ::std::string &s, const ::xercesc::DOMElement *e, ::xml_schema::Flags f = 0,
                 ::xml_schema::Container *c = 0);
 
    ParallelType(const ParallelType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
#ifdef XSD_CXX11
    ParallelType &operator=(const ParallelType &) = default;
#endif
 
    virtual ParallelType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    ParallelType &operator=(Value v);
 
    virtual operator Value() const { return _xsd_ParallelType_convert(); }
 
    //@cond
 
  protected:
    Value _xsd_ParallelType_convert() const;
 
  public:
    static const char *const _xsd_ParallelType_literals_[2];
    static const Value _xsd_ParallelType_indexes_[2];
 
    //@endcond
};
 
class BdConditionsType : public ::xml_schema::Type {
  public:
 
    typedef ::BoundaryConditionType NType;
 
    typedef ::xsd::cxx::tree::traits<NType, char> NTraits;
 
    const NType &n() const;
 
    NType &n();
 
    void n(const NType &x);
 
    void n(::std::unique_ptr<NType> p);
 
 
 
    typedef ::BoundaryConditionType SType;
 
    typedef ::xsd::cxx::tree::traits<SType, char> STraits;
 
    const SType &s() const;
 
    SType &s();
 
    void s(const SType &x);
 
    void s(::std::unique_ptr<SType> p);
 
 
 
    typedef ::BoundaryConditionType WType;
 
    typedef ::xsd::cxx::tree::traits<WType, char> WTraits;
 
    const WType &w() const;
 
    WType &w();
 
    void w(const WType &x);
 
    void w(::std::unique_ptr<WType> p);
 
 
 
    typedef ::BoundaryConditionType EType;
 
    typedef ::xsd::cxx::tree::traits<EType, char> ETraits;
 
    const EType &e() const;
 
    EType &e();
 
    void e(const EType &x);
 
    void e(::std::unique_ptr<EType> p);
 
 
 
    typedef ::BoundaryConditionType AType;
 
    typedef ::xsd::cxx::tree::traits<AType, char> ATraits;
 
    const AType &a() const;
 
    AType &a();
 
    void a(const AType &x);
 
    void a(::std::unique_ptr<AType> p);
 
 
 
    typedef ::BoundaryConditionType BType;
 
    typedef ::xsd::cxx::tree::traits<BType, char> BTraits;
 
    const BType &b() const;
 
    BType &b();
 
    void b(const BType &x);
 
    void b(::std::unique_ptr<BType> p);
 
 
 
    BdConditionsType(const NType &, const SType &, const WType &, const EType &, const AType &, const BType &);
 
    BdConditionsType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    BdConditionsType(const BdConditionsType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual BdConditionsType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    BdConditionsType &operator=(const BdConditionsType &x);
 
 
    virtual ~BdConditionsType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<NType> n_;
    ::xsd::cxx::tree::one<SType> s_;
    ::xsd::cxx::tree::one<WType> w_;
    ::xsd::cxx::tree::one<EType> e_;
    ::xsd::cxx::tree::one<AType> a_;
    ::xsd::cxx::tree::one<BType> b_;
 
    //@endcond
};
 
class BoundaryConditionType : public ::xml_schema::String {
  public:
    enum Value { outflow, reflective, periodic };
 
    BoundaryConditionType(Value v);
 
    BoundaryConditionType(const char *v);
 
    BoundaryConditionType(const ::std::string &v);
 
    BoundaryConditionType(const ::xml_schema::String &v);
 
    BoundaryConditionType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    BoundaryConditionType(const ::xercesc::DOMAttr &a, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    BoundaryConditionType(const ::std::string &s, const ::xercesc::DOMElement *e, ::xml_schema::Flags f = 0,
                          ::xml_schema::Container *c = 0);
 
    BoundaryConditionType(const BoundaryConditionType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
#ifdef XSD_CXX11
    BoundaryConditionType &operator=(const BoundaryConditionType &) = default;
#endif
 
    virtual BoundaryConditionType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    BoundaryConditionType &operator=(Value v);
 
    virtual operator Value() const { return _xsd_BoundaryConditionType_convert(); }
 
    //@cond
 
  protected:
    Value _xsd_BoundaryConditionType_convert() const;
 
  public:
    static const char *const _xsd_BoundaryConditionType_literals_[3];
    static const Value _xsd_BoundaryConditionType_indexes_[3];
 
    //@endcond
};
 
class PositionType : public ::xml_schema::Type {
  public:
 
    typedef ::xml_schema::Double XType;
 
    typedef ::xsd::cxx::tree::traits<XType, char, ::xsd::cxx::tree::schema_type::double_> XTraits;
 
    const XType &x() const;
 
    XType &x();
 
    void x(const XType &x);
 
 
 
    typedef ::xml_schema::Double YType;
 
    typedef ::xsd::cxx::tree::traits<YType, char, ::xsd::cxx::tree::schema_type::double_> YTraits;
 
    const YType &y() const;
 
    YType &y();
 
    void y(const YType &x);
 
 
 
    typedef ::xml_schema::Double ZType;
 
    typedef ::xsd::cxx::tree::traits<ZType, char, ::xsd::cxx::tree::schema_type::double_> ZTraits;
 
    const ZType &z() const;
 
    ZType &z();
 
    void z(const ZType &x);
 
 
 
    PositionType(const XType &, const YType &, const ZType &);
 
    PositionType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    PositionType(const PositionType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual PositionType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    PositionType &operator=(const PositionType &x);
 
 
    virtual ~PositionType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<XType> x_;
    ::xsd::cxx::tree::one<YType> y_;
    ::xsd::cxx::tree::one<ZType> z_;
 
    //@endcond
};
 
class VelocityType : public ::xml_schema::Type {
  public:
 
    typedef ::xml_schema::Double XType;
 
    typedef ::xsd::cxx::tree::traits<XType, char, ::xsd::cxx::tree::schema_type::double_> XTraits;
 
    const XType &x() const;
 
    XType &x();
 
    void x(const XType &x);
 
 
 
    typedef ::xml_schema::Double YType;
 
    typedef ::xsd::cxx::tree::traits<YType, char, ::xsd::cxx::tree::schema_type::double_> YTraits;
 
    const YType &y() const;
 
    YType &y();
 
    void y(const YType &x);
 
 
 
    typedef ::xml_schema::Double ZType;
 
    typedef ::xsd::cxx::tree::traits<ZType, char, ::xsd::cxx::tree::schema_type::double_> ZTraits;
 
    const ZType &z() const;
 
    ZType &z();
 
    void z(const ZType &x);
 
 
 
    VelocityType(const XType &, const YType &, const ZType &);
 
    VelocityType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    VelocityType(const VelocityType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual VelocityType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    VelocityType &operator=(const VelocityType &x);
 
 
    virtual ~VelocityType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<XType> x_;
    ::xsd::cxx::tree::one<YType> y_;
    ::xsd::cxx::tree::one<ZType> z_;
 
    //@endcond
};
 
class ForceType : public ::xml_schema::Type {
  public:
 
    typedef ::xml_schema::Double XType;
 
    typedef ::xsd::cxx::tree::traits<XType, char, ::xsd::cxx::tree::schema_type::double_> XTraits;
 
    const XType &x() const;
 
    XType &x();
 
    void x(const XType &x);
 
 
 
    typedef ::xml_schema::Double YType;
 
    typedef ::xsd::cxx::tree::traits<YType, char, ::xsd::cxx::tree::schema_type::double_> YTraits;
 
    const YType &y() const;
 
    YType &y();
 
    void y(const YType &x);
 
 
 
    typedef ::xml_schema::Double ZType;
 
    typedef ::xsd::cxx::tree::traits<ZType, char, ::xsd::cxx::tree::schema_type::double_> ZTraits;
 
    const ZType &z() const;
 
    ZType &z();
 
    void z(const ZType &x);
 
 
 
    ForceType(const XType &, const YType &, const ZType &);
 
    ForceType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    ForceType(const ForceType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual ForceType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    ForceType &operator=(const ForceType &x);
 
 
    virtual ~ForceType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<XType> x_;
    ::xsd::cxx::tree::one<YType> y_;
    ::xsd::cxx::tree::one<ZType> z_;
 
    //@endcond
};
 
class SizeType : public ::xml_schema::Type {
  public:
 
    typedef ::xml_schema::Double XType;
 
    typedef ::xsd::cxx::tree::traits<XType, char, ::xsd::cxx::tree::schema_type::double_> XTraits;
 
    const XType &x() const;
 
    XType &x();
 
    void x(const XType &x);
 
 
 
    typedef ::xml_schema::Double YType;
 
    typedef ::xsd::cxx::tree::traits<YType, char, ::xsd::cxx::tree::schema_type::double_> YTraits;
 
    const YType &y() const;
 
    YType &y();
 
    void y(const YType &x);
 
 
 
    typedef ::xml_schema::Double ZType;
 
    typedef ::xsd::cxx::tree::traits<ZType, char, ::xsd::cxx::tree::schema_type::double_> ZTraits;
 
    const ZType &z() const;
 
    ZType &z();
 
    void z(const ZType &x);
 
 
 
    SizeType(const XType &, const YType &, const ZType &);
 
    SizeType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    SizeType(const SizeType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual SizeType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    SizeType &operator=(const SizeType &x);
 
 
    virtual ~SizeType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<XType> x_;
    ::xsd::cxx::tree::one<YType> y_;
    ::xsd::cxx::tree::one<ZType> z_;
 
    //@endcond
};
 
class CuboidType : public ::xml_schema::Type {
  public:
 
    typedef ::PositionType PositionType;
 
    typedef ::xsd::cxx::tree::traits<PositionType, char> PositionTraits;
 
    const PositionType &position() const;
 
    PositionType &position();
 
    void position(const PositionType &x);
 
    void position(::std::unique_ptr<PositionType> p);
 
 
 
    typedef ::VelocityType VelocityType;
 
    typedef ::xsd::cxx::tree::traits<VelocityType, char> VelocityTraits;
 
    const VelocityType &velocity() const;
 
    VelocityType &velocity();
 
    void velocity(const VelocityType &x);
 
    void velocity(::std::unique_ptr<VelocityType> p);
 
 
 
    typedef ::SizeType SizeType;
 
    typedef ::xsd::cxx::tree::traits<SizeType, char> SizeTraits;
 
    const SizeType &size() const;
 
    SizeType &size();
 
    void size(const SizeType &x);
 
    void size(::std::unique_ptr<SizeType> p);
 
 
 
    typedef ::xml_schema::Double DistanceType;
 
    typedef ::xsd::cxx::tree::traits<DistanceType, char, ::xsd::cxx::tree::schema_type::double_> DistanceTraits;
 
    const DistanceType &distance() const;
 
    DistanceType &distance();
 
    void distance(const DistanceType &x);
 
 
 
    typedef ::xml_schema::Double MassType;
 
    typedef ::xsd::cxx::tree::traits<MassType, char, ::xsd::cxx::tree::schema_type::double_> MassTraits;
 
    const MassType &mass() const;
 
    MassType &mass();
 
    void mass(const MassType &x);
 
 
 
    typedef ::xml_schema::Int TypeType;
 
    typedef ::xsd::cxx::tree::optional<TypeType> TypeOptional;
 
    typedef ::xsd::cxx::tree::traits<TypeType, char> TypeTraits;
 
    const TypeOptional &type() const;
 
    TypeOptional &type();
 
    void type(const TypeType &x);
 
    void type(const TypeOptional &x);
 
 
 
    typedef ::xml_schema::Double EpsilonType;
 
    typedef ::xsd::cxx::tree::optional<EpsilonType> EpsilonOptional;
 
    typedef ::xsd::cxx::tree::traits<EpsilonType, char, ::xsd::cxx::tree::schema_type::double_> EpsilonTraits;
 
    const EpsilonOptional &epsilon() const;
 
    EpsilonOptional &epsilon();
 
    void epsilon(const EpsilonType &x);
 
    void epsilon(const EpsilonOptional &x);
 
 
 
    typedef ::xml_schema::Double SigmaType;
 
    typedef ::xsd::cxx::tree::optional<SigmaType> SigmaOptional;
 
    typedef ::xsd::cxx::tree::traits<SigmaType, char, ::xsd::cxx::tree::schema_type::double_> SigmaTraits;
 
    const SigmaOptional &sigma() const;
 
    SigmaOptional &sigma();
 
    void sigma(const SigmaType &x);
 
    void sigma(const SigmaOptional &x);
 
 
 
    CuboidType(const PositionType &, const VelocityType &, const SizeType &, const DistanceType &, const MassType &);
 
    CuboidType(::std::unique_ptr<PositionType>, ::std::unique_ptr<VelocityType>, ::std::unique_ptr<SizeType>,
               const DistanceType &, const MassType &);
 
    CuboidType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    CuboidType(const CuboidType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual CuboidType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    CuboidType &operator=(const CuboidType &x);
 
 
    virtual ~CuboidType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<PositionType> position_;
    ::xsd::cxx::tree::one<VelocityType> velocity_;
    ::xsd::cxx::tree::one<SizeType> size_;
    ::xsd::cxx::tree::one<DistanceType> distance_;
    ::xsd::cxx::tree::one<MassType> mass_;
    TypeOptional type_;
    EpsilonOptional epsilon_;
    SigmaOptional sigma_;
 
    //@endcond
};
 
class ParticleType : public ::xml_schema::Type {
  public:
 
    typedef ::PositionType PositionType;
 
    typedef ::xsd::cxx::tree::traits<PositionType, char> PositionTraits;
 
    const PositionType &position() const;
 
    PositionType &position();
 
    void position(const PositionType &x);
 
    void position(::std::unique_ptr<PositionType> p);
 
 
 
    typedef ::VelocityType VelocityType;
 
    typedef ::xsd::cxx::tree::traits<VelocityType, char> VelocityTraits;
 
    const VelocityType &velocity() const;
 
    VelocityType &velocity();
 
    void velocity(const VelocityType &x);
 
    void velocity(::std::unique_ptr<VelocityType> p);
 
 
 
    typedef ::ForceType ForceType;
 
    typedef ::xsd::cxx::tree::optional<ForceType> ForceOptional;
 
    typedef ::xsd::cxx::tree::traits<ForceType, char> ForceTraits;
 
    const ForceOptional &force() const;
 
    ForceOptional &force();
 
    void force(const ForceType &x);
 
    void force(const ForceOptional &x);
 
    void force(::std::unique_ptr<ForceType> p);
 
 
 
    typedef ::ForceType OldForceType;
 
    typedef ::xsd::cxx::tree::optional<OldForceType> OldForceOptional;
 
    typedef ::xsd::cxx::tree::traits<OldForceType, char> OldForceTraits;
 
    const OldForceOptional &oldForce() const;
 
    OldForceOptional &oldForce();
 
    void oldForce(const OldForceType &x);
 
    void oldForce(const OldForceOptional &x);
 
    void oldForce(::std::unique_ptr<OldForceType> p);
 
 
 
    typedef ::xml_schema::Double MassType;
 
    typedef ::xsd::cxx::tree::traits<MassType, char, ::xsd::cxx::tree::schema_type::double_> MassTraits;
 
    const MassType &mass() const;
 
    MassType &mass();
 
    void mass(const MassType &x);
 
 
 
    typedef ::xml_schema::Int TypeType;
 
    typedef ::xsd::cxx::tree::optional<TypeType> TypeOptional;
 
    typedef ::xsd::cxx::tree::traits<TypeType, char> TypeTraits;
 
    const TypeOptional &type() const;
 
    TypeOptional &type();
 
    void type(const TypeType &x);
 
    void type(const TypeOptional &x);
 
 
 
    typedef ::xml_schema::Double EpsilonType;
 
    typedef ::xsd::cxx::tree::optional<EpsilonType> EpsilonOptional;
 
    typedef ::xsd::cxx::tree::traits<EpsilonType, char, ::xsd::cxx::tree::schema_type::double_> EpsilonTraits;
 
    const EpsilonOptional &epsilon() const;
 
    EpsilonOptional &epsilon();
 
    void epsilon(const EpsilonType &x);
 
    void epsilon(const EpsilonOptional &x);
 
 
 
    typedef ::xml_schema::Double SigmaType;
 
    typedef ::xsd::cxx::tree::optional<SigmaType> SigmaOptional;
 
    typedef ::xsd::cxx::tree::traits<SigmaType, char, ::xsd::cxx::tree::schema_type::double_> SigmaTraits;
 
    const SigmaOptional &sigma() const;
 
    SigmaOptional &sigma();
 
    void sigma(const SigmaType &x);
 
    void sigma(const SigmaOptional &x);
 
 
 
    typedef ::xml_schema::Int CellIndexType;
 
    typedef ::xsd::cxx::tree::optional<CellIndexType> CellIndexOptional;
 
    typedef ::xsd::cxx::tree::traits<CellIndexType, char> CellIndexTraits;
 
    const CellIndexOptional &cellIndex() const;
 
    CellIndexOptional &cellIndex();
 
    void cellIndex(const CellIndexType &x);
 
    void cellIndex(const CellIndexOptional &x);
 
 
 
    ParticleType(const PositionType &, const VelocityType &, const MassType &);
 
    ParticleType(::std::unique_ptr<PositionType>, ::std::unique_ptr<VelocityType>, const MassType &);
 
    ParticleType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    ParticleType(const ParticleType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual ParticleType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    ParticleType &operator=(const ParticleType &x);
 
 
    virtual ~ParticleType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<PositionType> position_;
    ::xsd::cxx::tree::one<VelocityType> velocity_;
    ForceOptional force_;
    OldForceOptional oldForce_;
    ::xsd::cxx::tree::one<MassType> mass_;
    TypeOptional type_;
    EpsilonOptional epsilon_;
    SigmaOptional sigma_;
    CellIndexOptional cellIndex_;
 
    //@endcond
};
 
class DiscType : public ::xml_schema::Type {
  public:
 
    typedef ::PositionType PositionType;
 
    typedef ::xsd::cxx::tree::traits<PositionType, char> PositionTraits;
 
    const PositionType &position() const;
 
    PositionType &position();
 
    void position(const PositionType &x);
 
    void position(::std::unique_ptr<PositionType> p);
 
 
 
    typedef ::VelocityType VelocityType;
 
    typedef ::xsd::cxx::tree::traits<VelocityType, char> VelocityTraits;
 
    const VelocityType &velocity() const;
 
    VelocityType &velocity();
 
    void velocity(const VelocityType &x);
 
    void velocity(::std::unique_ptr<VelocityType> p);
 
 
 
    typedef ::xml_schema::Int RadiusType;
 
    typedef ::xsd::cxx::tree::traits<RadiusType, char> RadiusTraits;
 
    const RadiusType &radius() const;
 
    RadiusType &radius();
 
    void radius(const RadiusType &x);
 
 
 
    typedef ::xml_schema::Double DistanceType;
 
    typedef ::xsd::cxx::tree::traits<DistanceType, char, ::xsd::cxx::tree::schema_type::double_> DistanceTraits;
 
    const DistanceType &distance() const;
 
    DistanceType &distance();
 
    void distance(const DistanceType &x);
 
 
 
    typedef ::xml_schema::Double MassType;
 
    typedef ::xsd::cxx::tree::traits<MassType, char, ::xsd::cxx::tree::schema_type::double_> MassTraits;
 
    const MassType &mass() const;
 
    MassType &mass();
 
    void mass(const MassType &x);
 
 
 
    typedef ::xml_schema::Int TypeType;
 
    typedef ::xsd::cxx::tree::optional<TypeType> TypeOptional;
 
    typedef ::xsd::cxx::tree::traits<TypeType, char> TypeTraits;
 
    const TypeOptional &type() const;
 
    TypeOptional &type();
 
    void type(const TypeType &x);
 
    void type(const TypeOptional &x);
 
 
 
    typedef ::xml_schema::Double EpsilonType;
 
    typedef ::xsd::cxx::tree::optional<EpsilonType> EpsilonOptional;
 
    typedef ::xsd::cxx::tree::traits<EpsilonType, char, ::xsd::cxx::tree::schema_type::double_> EpsilonTraits;
 
    const EpsilonOptional &epsilon() const;
 
    EpsilonOptional &epsilon();
 
    void epsilon(const EpsilonType &x);
 
    void epsilon(const EpsilonOptional &x);
 
 
 
    typedef ::xml_schema::Double SigmaType;
 
    typedef ::xsd::cxx::tree::optional<SigmaType> SigmaOptional;
 
    typedef ::xsd::cxx::tree::traits<SigmaType, char, ::xsd::cxx::tree::schema_type::double_> SigmaTraits;
 
    const SigmaOptional &sigma() const;
 
    SigmaOptional &sigma();
 
    void sigma(const SigmaType &x);
 
    void sigma(const SigmaOptional &x);
 
 
 
    DiscType(const PositionType &, const VelocityType &, const RadiusType &, const DistanceType &, const MassType &);
 
    DiscType(::std::unique_ptr<PositionType>, ::std::unique_ptr<VelocityType>, const RadiusType &, const DistanceType &,
             const MassType &);
 
    DiscType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    DiscType(const DiscType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual DiscType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    DiscType &operator=(const DiscType &x);
 
 
    virtual ~DiscType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<PositionType> position_;
    ::xsd::cxx::tree::one<VelocityType> velocity_;
    ::xsd::cxx::tree::one<RadiusType> radius_;
    ::xsd::cxx::tree::one<DistanceType> distance_;
    ::xsd::cxx::tree::one<MassType> mass_;
    TypeOptional type_;
    EpsilonOptional epsilon_;
    SigmaOptional sigma_;
 
    //@endcond
};
 
class ObjectsType : public ::xml_schema::Type {
  public:
 
    typedef ::CuboidType CuboidType;
 
    typedef ::xsd::cxx::tree::sequence<CuboidType> CuboidSequence;
 
    typedef CuboidSequence::iterator CuboidIterator;
 
    typedef CuboidSequence::const_iterator CuboidConstIterator;
 
    typedef ::xsd::cxx::tree::traits<CuboidType, char> CuboidTraits;
 
    const CuboidSequence &cuboid() const;
 
    CuboidSequence &cuboid();
 
    void cuboid(const CuboidSequence &s);
 
 
 
    typedef ::ParticleType ParticleType;
 
    typedef ::xsd::cxx::tree::sequence<ParticleType> ParticleSequence;
 
    typedef ParticleSequence::iterator ParticleIterator;
 
    typedef ParticleSequence::const_iterator ParticleConstIterator;
 
    typedef ::xsd::cxx::tree::traits<ParticleType, char> ParticleTraits;
 
    const ParticleSequence &particle() const;
 
    ParticleSequence &particle();
 
    void particle(const ParticleSequence &s);
 
 
 
    typedef ::DiscType DiscType;
 
    typedef ::xsd::cxx::tree::sequence<DiscType> DiscSequence;
 
    typedef DiscSequence::iterator DiscIterator;
 
    typedef DiscSequence::const_iterator DiscConstIterator;
 
    typedef ::xsd::cxx::tree::traits<DiscType, char> DiscTraits;
 
    const DiscSequence &disc() const;
 
    DiscSequence &disc();
 
    void disc(const DiscSequence &s);
 
 
 
    ObjectsType();
 
    ObjectsType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    ObjectsType(const ObjectsType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual ObjectsType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    ObjectsType &operator=(const ObjectsType &x);
 
 
    virtual ~ObjectsType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    CuboidSequence cuboid_;
    ParticleSequence particle_;
    DiscSequence disc_;
 
    //@endcond
};
 
class SpecialCaseType : public ::xml_schema::Type {
  public:
 
    typedef ::xml_schema::Int XType;
 
    typedef ::xsd::cxx::tree::traits<XType, char> XTraits;
 
    const XType &x() const;
 
    XType &x();
 
    void x(const XType &x);
 
 
 
    typedef ::xml_schema::Int YType;
 
    typedef ::xsd::cxx::tree::traits<YType, char> YTraits;
 
    const YType &y() const;
 
    YType &y();
 
    void y(const YType &x);
 
 
 
    typedef ::xml_schema::Int ZType;
 
    typedef ::xsd::cxx::tree::traits<ZType, char> ZTraits;
 
    const ZType &z() const;
 
    ZType &z();
 
    void z(const ZType &x);
 
 
 
    SpecialCaseType(const XType &, const YType &, const ZType &);
 
    SpecialCaseType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    SpecialCaseType(const SpecialCaseType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual SpecialCaseType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    SpecialCaseType &operator=(const SpecialCaseType &x);
 
 
    virtual ~SpecialCaseType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<XType> x_;
    ::xsd::cxx::tree::one<YType> y_;
    ::xsd::cxx::tree::one<ZType> z_;
 
    //@endcond
};
 
class MembraneType : public ::xml_schema::Type {
  public:
 
    typedef ::xml_schema::Double StiffnessType;
 
    typedef ::xsd::cxx::tree::traits<StiffnessType, char, ::xsd::cxx::tree::schema_type::double_> StiffnessTraits;
 
    const StiffnessType &stiffness() const;
 
    StiffnessType &stiffness();
 
    void stiffness(const StiffnessType &x);
 
 
 
    typedef ::xml_schema::Double AvgBondLengthType;
 
    typedef ::xsd::cxx::tree::traits<AvgBondLengthType, char, ::xsd::cxx::tree::schema_type::double_>
        AvgBondLengthTraits;
 
    const AvgBondLengthType &avgBondLength() const;
 
    AvgBondLengthType &avgBondLength();
 
    void avgBondLength(const AvgBondLengthType &x);
 
 
 
    typedef ::xml_schema::Double ZForceType;
 
    typedef ::xsd::cxx::tree::traits<ZForceType, char, ::xsd::cxx::tree::schema_type::double_> ZForceTraits;
 
    const ZForceType &zForce() const;
 
    ZForceType &zForce();
 
    void zForce(const ZForceType &x);
 
 
 
    typedef ::SpecialCaseType SpecialCaseType;
 
    typedef ::xsd::cxx::tree::sequence<SpecialCaseType> SpecialCaseSequence;
 
    typedef SpecialCaseSequence::iterator SpecialCaseIterator;
 
    typedef SpecialCaseSequence::const_iterator SpecialCaseConstIterator;
 
    typedef ::xsd::cxx::tree::traits<SpecialCaseType, char> SpecialCaseTraits;
 
    const SpecialCaseSequence &specialCase() const;
 
    SpecialCaseSequence &specialCase();
 
    void specialCase(const SpecialCaseSequence &s);
 
 
 
    typedef ::xml_schema::Int ScIterationLimitType;
 
    typedef ::xsd::cxx::tree::optional<ScIterationLimitType> ScIterationLimitOptional;
 
    typedef ::xsd::cxx::tree::traits<ScIterationLimitType, char> ScIterationLimitTraits;
 
    const ScIterationLimitOptional &scIterationLimit() const;
 
    ScIterationLimitOptional &scIterationLimit();
 
    void scIterationLimit(const ScIterationLimitType &x);
 
    void scIterationLimit(const ScIterationLimitOptional &x);
 
 
 
    MembraneType(const StiffnessType &, const AvgBondLengthType &, const ZForceType &);
 
    MembraneType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    MembraneType(const MembraneType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual MembraneType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    MembraneType &operator=(const MembraneType &x);
 
 
    virtual ~MembraneType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<StiffnessType> stiffness_;
    ::xsd::cxx::tree::one<AvgBondLengthType> avgBondLength_;
    ::xsd::cxx::tree::one<ZForceType> zForce_;
    SpecialCaseSequence specialCase_;
    ScIterationLimitOptional scIterationLimit_;
 
    //@endcond
};
 
class AnalyzerType : public ::xml_schema::Type {
  public:
 
    typedef ::xml_schema::Int NBinsType;
 
    typedef ::xsd::cxx::tree::traits<NBinsType, char> NBinsTraits;
 
    const NBinsType &nBins() const;
 
    NBinsType &nBins();
 
    void nBins(const NBinsType &x);
 
 
 
    typedef ::xml_schema::Double LeftWallXType;
 
    typedef ::xsd::cxx::tree::traits<LeftWallXType, char, ::xsd::cxx::tree::schema_type::double_> LeftWallXTraits;
 
    const LeftWallXType &leftWallX() const;
 
    LeftWallXType &leftWallX();
 
    void leftWallX(const LeftWallXType &x);
 
 
 
    typedef ::xml_schema::Double RightWallXType;
 
    typedef ::xsd::cxx::tree::traits<RightWallXType, char, ::xsd::cxx::tree::schema_type::double_> RightWallXTraits;
 
    const RightWallXType &rightWallX() const;
 
    RightWallXType &rightWallX();
 
    void rightWallX(const RightWallXType &x);
 
 
 
    typedef ::xml_schema::Int FrequencyType;
 
    typedef ::xsd::cxx::tree::traits<FrequencyType, char> FrequencyTraits;
 
    const FrequencyType &frequency() const;
 
    FrequencyType &frequency();
 
    void frequency(const FrequencyType &x);
 
 
 
    typedef ::xml_schema::String DirnameType;
 
    typedef ::xsd::cxx::tree::optional<DirnameType> DirnameOptional;
 
    typedef ::xsd::cxx::tree::traits<DirnameType, char> DirnameTraits;
 
    const DirnameOptional &dirname() const;
 
    DirnameOptional &dirname();
 
    void dirname(const DirnameType &x);
 
    void dirname(const DirnameOptional &x);
 
    void dirname(::std::unique_ptr<DirnameType> p);
 
 
 
    AnalyzerType(const NBinsType &, const LeftWallXType &, const RightWallXType &, const FrequencyType &);
 
    AnalyzerType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    AnalyzerType(const AnalyzerType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual AnalyzerType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    AnalyzerType &operator=(const AnalyzerType &x);
 
 
    virtual ~AnalyzerType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<NBinsType> nBins_;
    ::xsd::cxx::tree::one<LeftWallXType> leftWallX_;
    ::xsd::cxx::tree::one<RightWallXType> rightWallX_;
    ::xsd::cxx::tree::one<FrequencyType> frequency_;
    DirnameOptional dirname_;
 
    //@endcond
};
 
class SimType : public ::xml_schema::Type {
  public:
 
    typedef ::ArgsType ArgsType;
 
    typedef ::xsd::cxx::tree::optional<ArgsType> ArgsOptional;
 
    typedef ::xsd::cxx::tree::traits<ArgsType, char> ArgsTraits;
 
    const ArgsOptional &args() const;
 
    ArgsOptional &args();
 
    void args(const ArgsType &x);
 
    void args(const ArgsOptional &x);
 
    void args(::std::unique_ptr<ArgsType> p);
 
 
 
    typedef ::ThermostatType ThermostatType;
 
    typedef ::xsd::cxx::tree::traits<ThermostatType, char> ThermostatTraits;
 
    const ThermostatType &thermostat() const;
 
    ThermostatType &thermostat();
 
    void thermostat(const ThermostatType &x);
 
    void thermostat(::std::unique_ptr<ThermostatType> p);
 
 
 
    typedef ::MembraneType MembraneType;
 
    typedef ::xsd::cxx::tree::optional<MembraneType> MembraneOptional;
 
    typedef ::xsd::cxx::tree::traits<MembraneType, char> MembraneTraits;
 
    const MembraneOptional &membrane() const;
 
    MembraneOptional &membrane();
 
    void membrane(const MembraneType &x);
 
    void membrane(const MembraneOptional &x);
 
    void membrane(::std::unique_ptr<MembraneType> p);
 
 
 
    typedef ::xml_schema::String TypeType;
 
    typedef ::xsd::cxx::tree::traits<TypeType, char> TypeTraits;
 
    const TypeType &type() const;
 
    TypeType &type();
 
    void type(const TypeType &x);
 
    void type(::std::unique_ptr<TypeType> p);
 
 
 
    typedef ::xml_schema::Boolean LinkedCellsType;
 
    typedef ::xsd::cxx::tree::optional<LinkedCellsType> LinkedCellsOptional;
 
    typedef ::xsd::cxx::tree::traits<LinkedCellsType, char> LinkedCellsTraits;
 
    const LinkedCellsOptional &linkedCells() const;
 
    LinkedCellsOptional &linkedCells();
 
    void linkedCells(const LinkedCellsType &x);
 
    void linkedCells(const LinkedCellsOptional &x);
 
 
 
    typedef ::xml_schema::PositiveInteger DimensionsType;
 
    typedef ::xsd::cxx::tree::optional<DimensionsType> DimensionsOptional;
 
    typedef ::xsd::cxx::tree::traits<DimensionsType, char> DimensionsTraits;
 
    const DimensionsOptional &dimensions() const;
 
    DimensionsOptional &dimensions();
 
    void dimensions(const DimensionsType &x);
 
    void dimensions(const DimensionsOptional &x);
 
 
 
    typedef ::AnalyzerType AnalyzerType;
 
    typedef ::xsd::cxx::tree::optional<AnalyzerType> AnalyzerOptional;
 
    typedef ::xsd::cxx::tree::traits<AnalyzerType, char> AnalyzerTraits;
 
    const AnalyzerOptional &analyzer() const;
 
    AnalyzerOptional &analyzer();
 
    void analyzer(const AnalyzerType &x);
 
    void analyzer(const AnalyzerOptional &x);
 
    void analyzer(::std::unique_ptr<AnalyzerType> p);
 
 
 
    typedef ::ObjectsType ObjectsType;
 
    typedef ::xsd::cxx::tree::traits<ObjectsType, char> ObjectsTraits;
 
    const ObjectsType &objects() const;
 
    ObjectsType &objects();
 
    void objects(const ObjectsType &x);
 
    void objects(::std::unique_ptr<ObjectsType> p);
 
 
 
    typedef ::xml_schema::Long TotalParticlesType;
 
    typedef ::xsd::cxx::tree::optional<TotalParticlesType> TotalParticlesOptional;
 
    typedef ::xsd::cxx::tree::traits<TotalParticlesType, char> TotalParticlesTraits;
 
    const TotalParticlesOptional &totalParticles() const;
 
    TotalParticlesOptional &totalParticles();
 
    void totalParticles(const TotalParticlesType &x);
 
    void totalParticles(const TotalParticlesOptional &x);
 
 
 
    SimType(const ThermostatType &, const TypeType &, const ObjectsType &);
 
    SimType(::std::unique_ptr<ThermostatType>, const TypeType &, ::std::unique_ptr<ObjectsType>);
 
    SimType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    SimType(const SimType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual SimType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    SimType &operator=(const SimType &x);
 
 
    virtual ~SimType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ArgsOptional args_;
    ::xsd::cxx::tree::one<ThermostatType> thermostat_;
    MembraneOptional membrane_;
    ::xsd::cxx::tree::one<TypeType> type_;
    LinkedCellsOptional linkedCells_;
    DimensionsOptional dimensions_;
    AnalyzerOptional analyzer_;
    ::xsd::cxx::tree::one<ObjectsType> objects_;
    TotalParticlesOptional totalParticles_;
 
    //@endcond
};
 
class ThermostatType : public ::xml_schema::Type {
  public:
 
    typedef ::xml_schema::Double InitType;
 
    typedef ::xsd::cxx::tree::traits<InitType, char, ::xsd::cxx::tree::schema_type::double_> InitTraits;
 
    const InitType &init() const;
 
    InitType &init();
 
    void init(const InitType &x);
 
 
 
    typedef ::xml_schema::Int TimeStepType;
 
    typedef ::xsd::cxx::tree::traits<TimeStepType, char> TimeStepTraits;
 
    const TimeStepType &timeStep() const;
 
    TimeStepType &timeStep();
 
    void timeStep(const TimeStepType &x);
 
 
 
    typedef ::xml_schema::Double TargetType;
 
    typedef ::xsd::cxx::tree::optional<TargetType> TargetOptional;
 
    typedef ::xsd::cxx::tree::traits<TargetType, char, ::xsd::cxx::tree::schema_type::double_> TargetTraits;
 
    const TargetOptional &target() const;
 
    TargetOptional &target();
 
    void target(const TargetType &x);
 
    void target(const TargetOptional &x);
 
 
 
    typedef ::xml_schema::Double DeltaTType;
 
    typedef ::xsd::cxx::tree::optional<DeltaTType> DeltaTOptional;
 
    typedef ::xsd::cxx::tree::traits<DeltaTType, char, ::xsd::cxx::tree::schema_type::double_> DeltaTTraits;
 
    const DeltaTOptional &deltaT() const;
 
    DeltaTOptional &deltaT();
 
    void deltaT(const DeltaTType &x);
 
    void deltaT(const DeltaTOptional &x);
 
 
 
    typedef ::xml_schema::Boolean BrownianMotionType;
 
    typedef ::xsd::cxx::tree::optional<BrownianMotionType> BrownianMotionOptional;
 
    typedef ::xsd::cxx::tree::traits<BrownianMotionType, char> BrownianMotionTraits;
 
    const BrownianMotionOptional &brownianMotion() const;
 
    BrownianMotionOptional &brownianMotion();
 
    void brownianMotion(const BrownianMotionType &x);
 
    void brownianMotion(const BrownianMotionOptional &x);
 
 
 
    typedef ::xml_schema::Boolean NanoFlowType;
 
    typedef ::xsd::cxx::tree::optional<NanoFlowType> NanoFlowOptional;
 
    typedef ::xsd::cxx::tree::traits<NanoFlowType, char> NanoFlowTraits;
 
    const NanoFlowOptional &nanoFlow() const;
 
    NanoFlowOptional &nanoFlow();
 
    void nanoFlow(const NanoFlowType &x);
 
    void nanoFlow(const NanoFlowOptional &x);
 
 
 
    ThermostatType(const InitType &, const TimeStepType &);
 
    ThermostatType(const ::xercesc::DOMElement &e, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    ThermostatType(const ThermostatType &x, ::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0);
 
    virtual ThermostatType *_clone(::xml_schema::Flags f = 0, ::xml_schema::Container *c = 0) const;
 
    ThermostatType &operator=(const ThermostatType &x);
 
 
    virtual ~ThermostatType();
 
    // Implementation.
    //
 
    //@cond
 
  protected:
    void parse(::xsd::cxx::xml::dom::parser<char> &, ::xml_schema::Flags);
 
  protected:
    ::xsd::cxx::tree::one<InitType> init_;
    ::xsd::cxx::tree::one<TimeStepType> timeStep_;
    TargetOptional target_;
    DeltaTOptional deltaT_;
    BrownianMotionOptional brownianMotion_;
    NanoFlowOptional nanoFlow_;
 
    //@endcond
};
 
#include <iosfwd>
 
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
#include <xercesc/sax/InputSource.hpp>
 
 
::std::unique_ptr<::SimType> sim(const ::std::string &uri, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(const ::std::string &uri, ::xml_schema::ErrorHandler &eh, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(const ::std::string &uri, ::xercesc::DOMErrorHandler &eh, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(::std::istream &is, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(::std::istream &is, ::xml_schema::ErrorHandler &eh, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(::std::istream &is, ::xercesc::DOMErrorHandler &eh, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(::std::istream &is, const ::std::string &id, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(::std::istream &is, const ::std::string &id, ::xml_schema::ErrorHandler &eh,
                                 ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(::std::istream &is, const ::std::string &id, ::xercesc::DOMErrorHandler &eh,
                                 ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(::xercesc::InputSource &is, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(::xercesc::InputSource &is, ::xml_schema::ErrorHandler &eh, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(::xercesc::InputSource &is, ::xercesc::DOMErrorHandler &eh, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(const ::xercesc::DOMDocument &d, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
::std::unique_ptr<::SimType> sim(::xml_schema::dom::unique_ptr<::xercesc::DOMDocument> d, ::xml_schema::Flags f = 0,
                                 const ::xml_schema::Properties &p = ::xml_schema::Properties());
 
 
#include <iosfwd>
 
#include <xercesc/dom/DOMDocument.hpp>
#include <xercesc/dom/DOMErrorHandler.hpp>
#include <xercesc/framework/XMLFormatter.hpp>
 
#include <xsd/cxx/xml/dom/auto-ptr.hxx>
 
 
void sim(::std::ostream &os, const ::SimType &x,
         const ::xml_schema::NamespaceInfomap &m = ::xml_schema::NamespaceInfomap(), const ::std::string &e = "UTF-8",
         ::xml_schema::Flags f = 0);
 
void sim(::std::ostream &os, const ::SimType &x, ::xml_schema::ErrorHandler &eh,
         const ::xml_schema::NamespaceInfomap &m = ::xml_schema::NamespaceInfomap(), const ::std::string &e = "UTF-8",
         ::xml_schema::Flags f = 0);
 
void sim(::std::ostream &os, const ::SimType &x, ::xercesc::DOMErrorHandler &eh,
         const ::xml_schema::NamespaceInfomap &m = ::xml_schema::NamespaceInfomap(), const ::std::string &e = "UTF-8",
         ::xml_schema::Flags f = 0);
 
void sim(::xercesc::XMLFormatTarget &ft, const ::SimType &x,
         const ::xml_schema::NamespaceInfomap &m = ::xml_schema::NamespaceInfomap(), const ::std::string &e = "UTF-8",
         ::xml_schema::Flags f = 0);
 
void sim(::xercesc::XMLFormatTarget &ft, const ::SimType &x, ::xml_schema::ErrorHandler &eh,
         const ::xml_schema::NamespaceInfomap &m = ::xml_schema::NamespaceInfomap(), const ::std::string &e = "UTF-8",
         ::xml_schema::Flags f = 0);
 
void sim(::xercesc::XMLFormatTarget &ft, const ::SimType &x, ::xercesc::DOMErrorHandler &eh,
         const ::xml_schema::NamespaceInfomap &m = ::xml_schema::NamespaceInfomap(), const ::std::string &e = "UTF-8",
         ::xml_schema::Flags f = 0);
 
void sim(::xercesc::DOMDocument &d, const ::SimType &x, ::xml_schema::Flags f = 0);
 
::xml_schema::dom::unique_ptr<::xercesc::DOMDocument>
sim(const ::SimType &x, const ::xml_schema::NamespaceInfomap &m = ::xml_schema::NamespaceInfomap(),
    ::xml_schema::Flags f = 0);
 
 
void operator<<(::xercesc::DOMElement &, const ArgsType &);
 
void operator<<(::xercesc::DOMElement &, const ParallelType &);
 
void operator<<(::xercesc::DOMAttr &, const ParallelType &);
 
void operator<<(::xml_schema::ListStream &, const ParallelType &);
 
void operator<<(::xercesc::DOMElement &, const BdConditionsType &);
 
void operator<<(::xercesc::DOMElement &, const BoundaryConditionType &);
 
void operator<<(::xercesc::DOMAttr &, const BoundaryConditionType &);
 
void operator<<(::xml_schema::ListStream &, const BoundaryConditionType &);
 
void operator<<(::xercesc::DOMElement &, const PositionType &);
 
void operator<<(::xercesc::DOMElement &, const VelocityType &);
 
void operator<<(::xercesc::DOMElement &, const ForceType &);
 
void operator<<(::xercesc::DOMElement &, const SizeType &);
 
void operator<<(::xercesc::DOMElement &, const CuboidType &);
 
void operator<<(::xercesc::DOMElement &, const ParticleType &);
 
void operator<<(::xercesc::DOMElement &, const DiscType &);
 
void operator<<(::xercesc::DOMElement &, const ObjectsType &);
 
void operator<<(::xercesc::DOMElement &, const SpecialCaseType &);
 
void operator<<(::xercesc::DOMElement &, const MembraneType &);
 
void operator<<(::xercesc::DOMElement &, const AnalyzerType &);
 
void operator<<(::xercesc::DOMElement &, const SimType &);
 
void operator<<(::xercesc::DOMElement &, const ThermostatType &);
 
#include <xsd/cxx/post.hxx>
 
// Begin epilogue.
//
//
// End epilogue.
 
#endif // SIMULATION_XSD_H