From 28c505bfb2476d6a840676787efcd3f58e0550ec Mon Sep 17 00:00:00 2001 From: "Ankur Sinha (Ankur Sinha Gmail)" Date: Thu, 30 Nov 2023 11:51:18 +0000 Subject: [PATCH 1/2] chore: update readme --- README.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.md b/README.md index 53c7409..d10115d 100644 --- a/README.md +++ b/README.md @@ -78,7 +78,7 @@ On Fedora and other RPM based distributions, you can install Xerces and xsd from the standard repositories using `dnf` or `yum`: ``` -sudo dnf install xsd xerces-c-devel +sudo dnf install xsd xerces-c-devel doxygen ``` If you install xsd in a non-standard location, please set the `XSD_ROOT` From aeff0de8bb917bb81e5e5253261344a844230322 Mon Sep 17 00:00:00 2001 From: "Ankur Sinha (Ankur Sinha Gmail)" Date: Thu, 30 Nov 2023 11:53:47 +0000 Subject: [PATCH 2/2] feat: update to 2.3.0 --- CMakeLists.txt | 4 +- .../{NeuroML_v2.2.cxx => NeuroML_v2.3.cxx} | 5291 ++++- .../{NeuroML_v2.2.hxx => NeuroML_v2.3.hxx} | 16745 ++++++++++------ .../{NeuroML_v2.2.xsd => NeuroML_v2.3.xsd} | 659 +- update.sh | 3 +- 5 files changed, 15692 insertions(+), 7010 deletions(-) rename src/schema/{NeuroML_v2.2.cxx => NeuroML_v2.3.cxx} (93%) rename src/schema/{NeuroML_v2.2.hxx => NeuroML_v2.3.hxx} (93%) rename src/schema/{NeuroML_v2.2.xsd => NeuroML_v2.3.xsd} (87%) diff --git a/CMakeLists.txt b/CMakeLists.txt index 3b83b59..cf4bb55 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -11,7 +11,7 @@ cmake_policy(SET CMP0048 NEW) # VERSION option to project() # Note: the version number uses Semantic Versioning http://semver.org/ project(NeuroML_API - VERSION 2.2.0 + VERSION 2.3.0 DESCRIPTION "C++ API for NeuroML 2" HOMEPAGE_URL "https://github.com/NeuroML/NeuroML_API" ) @@ -21,7 +21,7 @@ set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} ${PROJECT_SOURCE_DIR}/cmake/modules) ############################ # Which schema to provide the API for -set(NeuroML_SCHEMA_PATH "${PROJECT_SOURCE_DIR}/src/schema/NeuroML_v2.2.xsd" +set(NeuroML_SCHEMA_PATH "${PROJECT_SOURCE_DIR}/src/schema/NeuroML_v2.3.xsd" CACHE PATH "Path to the schema file to base the API on.") diff --git a/src/schema/NeuroML_v2.2.cxx b/src/schema/NeuroML_v2.3.cxx similarity index 93% rename from src/schema/NeuroML_v2.2.cxx rename to src/schema/NeuroML_v2.3.cxx index 28de1c3..cf01fc8 100644 --- a/src/schema/NeuroML_v2.2.cxx +++ b/src/schema/NeuroML_v2.3.cxx @@ -39,7 +39,7 @@ #include -#include "NeuroML_v2.2.hxx" +#include "NeuroML_v2.3.hxx" namespace neuroml2 { @@ -131,6 +131,10 @@ namespace neuroml2 // + // Nml2PopulationReferencePath + // + + // NonNegativeInteger // @@ -164,6 +168,10 @@ namespace neuroml2 // + // BaseWithoutId + // + + // Property // @@ -259,6 +267,24 @@ namespace neuroml2 this->Parameter_ = s; } + const ComponentType::DerivedParameter_sequence& ComponentType:: + DerivedParameter () const + { + return this->DerivedParameter_; + } + + ComponentType::DerivedParameter_sequence& ComponentType:: + DerivedParameter () + { + return this->DerivedParameter_; + } + + void ComponentType:: + DerivedParameter (const DerivedParameter_sequence& s) + { + this->DerivedParameter_ = s; + } + const ComponentType::Constant_sequence& ComponentType:: Constant () const { @@ -820,6 +846,34 @@ namespace neuroml2 // + // DerivedParameter + // + + const DerivedParameter::value_type& DerivedParameter:: + value () const + { + return this->value_.get (); + } + + DerivedParameter::value_type& DerivedParameter:: + value () + { + return this->value_.get (); + } + + void DerivedParameter:: + value (const value_type& x) + { + this->value_.set (x); + } + + void DerivedParameter:: + value (::std::unique_ptr< value_type > x) + { + this->value_.set (std::move (x)); + } + + // LEMS_Property // @@ -979,6 +1033,90 @@ namespace neuroml2 this->TimeDerivative_ = s; } + const Dynamics::OnStart_optional& Dynamics:: + OnStart () const + { + return this->OnStart_; + } + + Dynamics::OnStart_optional& Dynamics:: + OnStart () + { + return this->OnStart_; + } + + void Dynamics:: + OnStart (const OnStart_type& x) + { + this->OnStart_.set (x); + } + + void Dynamics:: + OnStart (const OnStart_optional& x) + { + this->OnStart_ = x; + } + + void Dynamics:: + OnStart (::std::unique_ptr< OnStart_type > x) + { + this->OnStart_.set (std::move (x)); + } + + const Dynamics::OnEvent_sequence& Dynamics:: + OnEvent () const + { + return this->OnEvent_; + } + + Dynamics::OnEvent_sequence& Dynamics:: + OnEvent () + { + return this->OnEvent_; + } + + void Dynamics:: + OnEvent (const OnEvent_sequence& s) + { + this->OnEvent_ = s; + } + + const Dynamics::OnCondition_sequence& Dynamics:: + OnCondition () const + { + return this->OnCondition_; + } + + Dynamics::OnCondition_sequence& Dynamics:: + OnCondition () + { + return this->OnCondition_; + } + + void Dynamics:: + OnCondition (const OnCondition_sequence& s) + { + this->OnCondition_ = s; + } + + const Dynamics::Regime_sequence& Dynamics:: + Regime () const + { + return this->Regime_; + } + + Dynamics::Regime_sequence& Dynamics:: + Regime () + { + return this->Regime_; + } + + void Dynamics:: + Regime (const Regime_sequence& s) + { + this->Regime_ = s; + } + // DerivedVariable // @@ -1180,43 +1318,488 @@ namespace neuroml2 } - // ZeroToOne + // OnStart // + const OnStart::StateAssignment_sequence& OnStart:: + StateAssignment () const + { + return this->StateAssignment_; + } - // BaseWithoutId + OnStart::StateAssignment_sequence& OnStart:: + StateAssignment () + { + return this->StateAssignment_; + } + + void OnStart:: + StateAssignment (const StateAssignment_sequence& s) + { + this->StateAssignment_ = s; + } + + + // StateAssignment // - const BaseWithoutId::neuroLexId_optional& BaseWithoutId:: - neuroLexId () const + const StateAssignment::variable_type& StateAssignment:: + variable () const { - return this->neuroLexId_; + return this->variable_.get (); } - BaseWithoutId::neuroLexId_optional& BaseWithoutId:: - neuroLexId () + StateAssignment::variable_type& StateAssignment:: + variable () { - return this->neuroLexId_; + return this->variable_.get (); } - void BaseWithoutId:: - neuroLexId (const neuroLexId_type& x) + void StateAssignment:: + variable (const variable_type& x) { - this->neuroLexId_.set (x); + this->variable_.set (x); } - void BaseWithoutId:: - neuroLexId (const neuroLexId_optional& x) + void StateAssignment:: + variable (::std::unique_ptr< variable_type > x) { - this->neuroLexId_ = x; + this->variable_.set (std::move (x)); } - void BaseWithoutId:: - neuroLexId (::std::unique_ptr< neuroLexId_type > x) + const StateAssignment::value_type& StateAssignment:: + value () const { - this->neuroLexId_.set (std::move (x)); + return this->value_.get (); + } + + StateAssignment::value_type& StateAssignment:: + value () + { + return this->value_.get (); + } + + void StateAssignment:: + value (const value_type& x) + { + this->value_.set (x); + } + + void StateAssignment:: + value (::std::unique_ptr< value_type > x) + { + this->value_.set (std::move (x)); + } + + + // OnEvent + // + + const OnEvent::StateAssignment_sequence& OnEvent:: + StateAssignment () const + { + return this->StateAssignment_; + } + + OnEvent::StateAssignment_sequence& OnEvent:: + StateAssignment () + { + return this->StateAssignment_; + } + + void OnEvent:: + StateAssignment (const StateAssignment_sequence& s) + { + this->StateAssignment_ = s; + } + + const OnEvent::EventOut_sequence& OnEvent:: + EventOut () const + { + return this->EventOut_; + } + + OnEvent::EventOut_sequence& OnEvent:: + EventOut () + { + return this->EventOut_; + } + + void OnEvent:: + EventOut (const EventOut_sequence& s) + { + this->EventOut_ = s; + } + + const OnEvent::port_type& OnEvent:: + port () const + { + return this->port_.get (); + } + + OnEvent::port_type& OnEvent:: + port () + { + return this->port_.get (); + } + + void OnEvent:: + port (const port_type& x) + { + this->port_.set (x); + } + + void OnEvent:: + port (::std::unique_ptr< port_type > x) + { + this->port_.set (std::move (x)); + } + + + // EventOut + // + + const EventOut::port_type& EventOut:: + port () const + { + return this->port_.get (); } + EventOut::port_type& EventOut:: + port () + { + return this->port_.get (); + } + + void EventOut:: + port (const port_type& x) + { + this->port_.set (x); + } + + void EventOut:: + port (::std::unique_ptr< port_type > x) + { + this->port_.set (std::move (x)); + } + + + // OnCondition + // + + const OnCondition::StateAssignment_sequence& OnCondition:: + StateAssignment () const + { + return this->StateAssignment_; + } + + OnCondition::StateAssignment_sequence& OnCondition:: + StateAssignment () + { + return this->StateAssignment_; + } + + void OnCondition:: + StateAssignment (const StateAssignment_sequence& s) + { + this->StateAssignment_ = s; + } + + const OnCondition::EventOut_sequence& OnCondition:: + EventOut () const + { + return this->EventOut_; + } + + OnCondition::EventOut_sequence& OnCondition:: + EventOut () + { + return this->EventOut_; + } + + void OnCondition:: + EventOut (const EventOut_sequence& s) + { + this->EventOut_ = s; + } + + const OnCondition::Transition_optional& OnCondition:: + Transition () const + { + return this->Transition_; + } + + OnCondition::Transition_optional& OnCondition:: + Transition () + { + return this->Transition_; + } + + void OnCondition:: + Transition (const Transition_type& x) + { + this->Transition_.set (x); + } + + void OnCondition:: + Transition (const Transition_optional& x) + { + this->Transition_ = x; + } + + void OnCondition:: + Transition (::std::unique_ptr< Transition_type > x) + { + this->Transition_.set (std::move (x)); + } + + const OnCondition::test_type& OnCondition:: + test () const + { + return this->test_.get (); + } + + OnCondition::test_type& OnCondition:: + test () + { + return this->test_.get (); + } + + void OnCondition:: + test (const test_type& x) + { + this->test_.set (x); + } + + void OnCondition:: + test (::std::unique_ptr< test_type > x) + { + this->test_.set (std::move (x)); + } + + + // Transition + // + + const Transition::regime_type& Transition:: + regime () const + { + return this->regime_.get (); + } + + Transition::regime_type& Transition:: + regime () + { + return this->regime_.get (); + } + + void Transition:: + regime (const regime_type& x) + { + this->regime_.set (x); + } + + void Transition:: + regime (::std::unique_ptr< regime_type > x) + { + this->regime_.set (std::move (x)); + } + + + // Regime + // + + const Regime::TimeDerivative_sequence& Regime:: + TimeDerivative () const + { + return this->TimeDerivative_; + } + + Regime::TimeDerivative_sequence& Regime:: + TimeDerivative () + { + return this->TimeDerivative_; + } + + void Regime:: + TimeDerivative (const TimeDerivative_sequence& s) + { + this->TimeDerivative_ = s; + } + + const Regime::OnEntry_optional& Regime:: + OnEntry () const + { + return this->OnEntry_; + } + + Regime::OnEntry_optional& Regime:: + OnEntry () + { + return this->OnEntry_; + } + + void Regime:: + OnEntry (const OnEntry_type& x) + { + this->OnEntry_.set (x); + } + + void Regime:: + OnEntry (const OnEntry_optional& x) + { + this->OnEntry_ = x; + } + + void Regime:: + OnEntry (::std::unique_ptr< OnEntry_type > x) + { + this->OnEntry_.set (std::move (x)); + } + + const Regime::OnCondition_sequence& Regime:: + OnCondition () const + { + return this->OnCondition_; + } + + Regime::OnCondition_sequence& Regime:: + OnCondition () + { + return this->OnCondition_; + } + + void Regime:: + OnCondition (const OnCondition_sequence& s) + { + this->OnCondition_ = s; + } + + const Regime::name_type& Regime:: + name () const + { + return this->name_.get (); + } + + Regime::name_type& Regime:: + name () + { + return this->name_.get (); + } + + void Regime:: + name (const name_type& x) + { + this->name_.set (x); + } + + void Regime:: + name (::std::unique_ptr< name_type > x) + { + this->name_.set (std::move (x)); + } + + const Regime::initial_optional& Regime:: + initial () const + { + return this->initial_; + } + + Regime::initial_optional& Regime:: + initial () + { + return this->initial_; + } + + void Regime:: + initial (const initial_type& x) + { + this->initial_.set (x); + } + + void Regime:: + initial (const initial_optional& x) + { + this->initial_ = x; + } + + void Regime:: + initial (::std::unique_ptr< initial_type > x) + { + this->initial_.set (std::move (x)); + } + + + // OnEntry + // + + const OnEntry::StateAssignment_sequence& OnEntry:: + StateAssignment () const + { + return this->StateAssignment_; + } + + OnEntry::StateAssignment_sequence& OnEntry:: + StateAssignment () + { + return this->StateAssignment_; + } + + void OnEntry:: + StateAssignment (const StateAssignment_sequence& s) + { + this->StateAssignment_ = s; + } + + + // TrueOrFalse + // + + TrueOrFalse:: + TrueOrFalse (value v) + : ::xml_schema::string (_xsd_TrueOrFalse_literals_[v]) + { + } + + TrueOrFalse:: + TrueOrFalse (const char* v) + : ::xml_schema::string (v) + { + } + + TrueOrFalse:: + TrueOrFalse (const ::std::string& v) + : ::xml_schema::string (v) + { + } + + TrueOrFalse:: + TrueOrFalse (const ::xml_schema::string& v) + : ::xml_schema::string (v) + { + } + + TrueOrFalse:: + TrueOrFalse (const TrueOrFalse& v, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (v, f, c) + { + } + + TrueOrFalse& TrueOrFalse:: + operator= (value v) + { + static_cast< ::xml_schema::string& > (*this) = + ::xml_schema::string (_xsd_TrueOrFalse_literals_[v]); + + return *this; + } + + + // ZeroToOne + // + // Base // @@ -1991,6 +2574,24 @@ namespace neuroml2 this->pinskyRinzelCA3Cell_ = s; } + const NeuroMLDocument_base::hindmarshRose1984Cell_sequence& NeuroMLDocument_base:: + hindmarshRose1984Cell () const + { + return this->hindmarshRose1984Cell_; + } + + NeuroMLDocument_base::hindmarshRose1984Cell_sequence& NeuroMLDocument_base:: + hindmarshRose1984Cell () + { + return this->hindmarshRose1984Cell_; + } + + void NeuroMLDocument_base:: + hindmarshRose1984Cell (const hindmarshRose1984Cell_sequence& s) + { + this->hindmarshRose1984Cell_ = s; + } + const NeuroMLDocument_base::pulseGenerator_sequence& NeuroMLDocument_base:: pulseGenerator () const { @@ -2617,6 +3218,36 @@ namespace neuroml2 this->q10ConductanceScaling_ = s; } + const IonChannelScalable::neuroLexId_optional& IonChannelScalable:: + neuroLexId () const + { + return this->neuroLexId_; + } + + IonChannelScalable::neuroLexId_optional& IonChannelScalable:: + neuroLexId () + { + return this->neuroLexId_; + } + + void IonChannelScalable:: + neuroLexId (const neuroLexId_type& x) + { + this->neuroLexId_.set (x); + } + + void IonChannelScalable:: + neuroLexId (const neuroLexId_optional& x) + { + this->neuroLexId_ = x; + } + + void IonChannelScalable:: + neuroLexId (::std::unique_ptr< neuroLexId_type > x) + { + this->neuroLexId_.set (std::move (x)); + } + // IonChannelKS // @@ -2699,6 +3330,36 @@ namespace neuroml2 this->conductance_.set (std::move (x)); } + const IonChannelKS::neuroLexId_optional& IonChannelKS:: + neuroLexId () const + { + return this->neuroLexId_; + } + + IonChannelKS::neuroLexId_optional& IonChannelKS:: + neuroLexId () + { + return this->neuroLexId_; + } + + void IonChannelKS:: + neuroLexId (const neuroLexId_type& x) + { + this->neuroLexId_.set (x); + } + + void IonChannelKS:: + neuroLexId (const neuroLexId_optional& x) + { + this->neuroLexId_ = x; + } + + void IonChannelKS:: + neuroLexId (::std::unique_ptr< neuroLexId_type > x) + { + this->neuroLexId_.set (std::move (x)); + } + // IonChannel // @@ -5551,6 +6212,36 @@ namespace neuroml2 // BaseSynapse // + const BaseSynapse::neuroLexId_optional& BaseSynapse:: + neuroLexId () const + { + return this->neuroLexId_; + } + + BaseSynapse::neuroLexId_optional& BaseSynapse:: + neuroLexId () + { + return this->neuroLexId_; + } + + void BaseSynapse:: + neuroLexId (const neuroLexId_type& x) + { + this->neuroLexId_.set (x); + } + + void BaseSynapse:: + neuroLexId (const neuroLexId_optional& x) + { + this->neuroLexId_ = x; + } + + void BaseSynapse:: + neuroLexId (::std::unique_ptr< neuroLexId_type > x) + { + this->neuroLexId_.set (std::move (x)); + } + // BaseVoltageDepSynapse // @@ -6595,6 +7286,36 @@ namespace neuroml2 // BaseCell // + const BaseCell::neuroLexId_optional& BaseCell:: + neuroLexId () const + { + return this->neuroLexId_; + } + + BaseCell::neuroLexId_optional& BaseCell:: + neuroLexId () + { + return this->neuroLexId_; + } + + void BaseCell:: + neuroLexId (const neuroLexId_type& x) + { + this->neuroLexId_.set (x); + } + + void BaseCell:: + neuroLexId (const neuroLexId_optional& x) + { + this->neuroLexId_ = x; + } + + void BaseCell:: + neuroLexId (::std::unique_ptr< neuroLexId_type > x) + { + this->neuroLexId_.set (std::move (x)); + } + // IafTauCell // @@ -8200,6 +8921,274 @@ namespace neuroml2 } + // HindmarshRose1984Cell + // + + const HindmarshRose1984Cell::a_type& HindmarshRose1984Cell:: + a () const + { + return this->a_.get (); + } + + HindmarshRose1984Cell::a_type& HindmarshRose1984Cell:: + a () + { + return this->a_.get (); + } + + void HindmarshRose1984Cell:: + a (const a_type& x) + { + this->a_.set (x); + } + + void HindmarshRose1984Cell:: + a (::std::unique_ptr< a_type > x) + { + this->a_.set (std::move (x)); + } + + const HindmarshRose1984Cell::b_type& HindmarshRose1984Cell:: + b () const + { + return this->b_.get (); + } + + HindmarshRose1984Cell::b_type& HindmarshRose1984Cell:: + b () + { + return this->b_.get (); + } + + void HindmarshRose1984Cell:: + b (const b_type& x) + { + this->b_.set (x); + } + + void HindmarshRose1984Cell:: + b (::std::unique_ptr< b_type > x) + { + this->b_.set (std::move (x)); + } + + const HindmarshRose1984Cell::c_type& HindmarshRose1984Cell:: + c () const + { + return this->c_.get (); + } + + HindmarshRose1984Cell::c_type& HindmarshRose1984Cell:: + c () + { + return this->c_.get (); + } + + void HindmarshRose1984Cell:: + c (const c_type& x) + { + this->c_.set (x); + } + + void HindmarshRose1984Cell:: + c (::std::unique_ptr< c_type > x) + { + this->c_.set (std::move (x)); + } + + const HindmarshRose1984Cell::d_type& HindmarshRose1984Cell:: + d () const + { + return this->d_.get (); + } + + HindmarshRose1984Cell::d_type& HindmarshRose1984Cell:: + d () + { + return this->d_.get (); + } + + void HindmarshRose1984Cell:: + d (const d_type& x) + { + this->d_.set (x); + } + + void HindmarshRose1984Cell:: + d (::std::unique_ptr< d_type > x) + { + this->d_.set (std::move (x)); + } + + const HindmarshRose1984Cell::s_type& HindmarshRose1984Cell:: + s () const + { + return this->s_.get (); + } + + HindmarshRose1984Cell::s_type& HindmarshRose1984Cell:: + s () + { + return this->s_.get (); + } + + void HindmarshRose1984Cell:: + s (const s_type& x) + { + this->s_.set (x); + } + + void HindmarshRose1984Cell:: + s (::std::unique_ptr< s_type > x) + { + this->s_.set (std::move (x)); + } + + const HindmarshRose1984Cell::x1_type& HindmarshRose1984Cell:: + x1 () const + { + return this->x1_.get (); + } + + HindmarshRose1984Cell::x1_type& HindmarshRose1984Cell:: + x1 () + { + return this->x1_.get (); + } + + void HindmarshRose1984Cell:: + x1 (const x1_type& x) + { + this->x1_.set (x); + } + + void HindmarshRose1984Cell:: + x1 (::std::unique_ptr< x1_type > x) + { + this->x1_.set (std::move (x)); + } + + const HindmarshRose1984Cell::r_type& HindmarshRose1984Cell:: + r () const + { + return this->r_.get (); + } + + HindmarshRose1984Cell::r_type& HindmarshRose1984Cell:: + r () + { + return this->r_.get (); + } + + void HindmarshRose1984Cell:: + r (const r_type& x) + { + this->r_.set (x); + } + + void HindmarshRose1984Cell:: + r (::std::unique_ptr< r_type > x) + { + this->r_.set (std::move (x)); + } + + const HindmarshRose1984Cell::x0_type& HindmarshRose1984Cell:: + x0 () const + { + return this->x0_.get (); + } + + HindmarshRose1984Cell::x0_type& HindmarshRose1984Cell:: + x0 () + { + return this->x0_.get (); + } + + void HindmarshRose1984Cell:: + x0 (const x0_type& x) + { + this->x0_.set (x); + } + + void HindmarshRose1984Cell:: + x0 (::std::unique_ptr< x0_type > x) + { + this->x0_.set (std::move (x)); + } + + const HindmarshRose1984Cell::y0_type& HindmarshRose1984Cell:: + y0 () const + { + return this->y0_.get (); + } + + HindmarshRose1984Cell::y0_type& HindmarshRose1984Cell:: + y0 () + { + return this->y0_.get (); + } + + void HindmarshRose1984Cell:: + y0 (const y0_type& x) + { + this->y0_.set (x); + } + + void HindmarshRose1984Cell:: + y0 (::std::unique_ptr< y0_type > x) + { + this->y0_.set (std::move (x)); + } + + const HindmarshRose1984Cell::z0_type& HindmarshRose1984Cell:: + z0 () const + { + return this->z0_.get (); + } + + HindmarshRose1984Cell::z0_type& HindmarshRose1984Cell:: + z0 () + { + return this->z0_.get (); + } + + void HindmarshRose1984Cell:: + z0 (const z0_type& x) + { + this->z0_.set (x); + } + + void HindmarshRose1984Cell:: + z0 (::std::unique_ptr< z0_type > x) + { + this->z0_.set (std::move (x)); + } + + const HindmarshRose1984Cell::v_scaling_type& HindmarshRose1984Cell:: + v_scaling () const + { + return this->v_scaling_.get (); + } + + HindmarshRose1984Cell::v_scaling_type& HindmarshRose1984Cell:: + v_scaling () + { + return this->v_scaling_.get (); + } + + void HindmarshRose1984Cell:: + v_scaling (const v_scaling_type& x) + { + this->v_scaling_.set (x); + } + + void HindmarshRose1984Cell:: + v_scaling (::std::unique_ptr< v_scaling_type > x) + { + this->v_scaling_.set (std::move (x)); + } + + // Cell // @@ -8543,6 +9532,36 @@ namespace neuroml2 this->name_.set (std::move (x)); } + const Segment_base::neuroLexId_optional& Segment_base:: + neuroLexId () const + { + return this->neuroLexId_; + } + + Segment_base::neuroLexId_optional& Segment_base:: + neuroLexId () + { + return this->neuroLexId_; + } + + void Segment_base:: + neuroLexId (const neuroLexId_type& x) + { + this->neuroLexId_.set (x); + } + + void Segment_base:: + neuroLexId (const neuroLexId_optional& x) + { + this->neuroLexId_ = x; + } + + void Segment_base:: + neuroLexId (::std::unique_ptr< neuroLexId_type > x) + { + this->neuroLexId_.set (std::move (x)); + } + // SegmentParent // @@ -8855,6 +9874,36 @@ namespace neuroml2 this->inhomogeneousParameter_ = s; } + const SegmentGroup::neuroLexId_optional& SegmentGroup:: + neuroLexId () const + { + return this->neuroLexId_; + } + + SegmentGroup::neuroLexId_optional& SegmentGroup:: + neuroLexId () + { + return this->neuroLexId_; + } + + void SegmentGroup:: + neuroLexId (const neuroLexId_type& x) + { + this->neuroLexId_.set (x); + } + + void SegmentGroup:: + neuroLexId (const neuroLexId_optional& x) + { + this->neuroLexId_ = x; + } + + void SegmentGroup:: + neuroLexId (::std::unique_ptr< neuroLexId_type > x) + { + this->neuroLexId_.set (std::move (x)); + } + // InhomogeneousParameter // @@ -11122,30 +12171,6 @@ namespace neuroml2 // Species // - const Species::id_type& Species:: - id () const - { - return this->id_.get (); - } - - Species::id_type& Species:: - id () - { - return this->id_.get (); - } - - void Species:: - id (const id_type& x) - { - this->id_.set (x); - } - - void Species:: - id (::std::unique_ptr< id_type > x) - { - this->id_.set (std::move (x)); - } - const Species::concentrationModel_type& Species:: concentrationModel () const { @@ -13188,6 +14213,36 @@ namespace neuroml2 this->temperature_.set (std::move (x)); } + const Network::neuroLexId_optional& Network:: + neuroLexId () const + { + return this->neuroLexId_; + } + + Network::neuroLexId_optional& Network:: + neuroLexId () + { + return this->neuroLexId_; + } + + void Network:: + neuroLexId (const neuroLexId_type& x) + { + this->neuroLexId_.set (x); + } + + void Network:: + neuroLexId (const neuroLexId_optional& x) + { + this->neuroLexId_ = x; + } + + void Network:: + neuroLexId (::std::unique_ptr< neuroLexId_type > x) + { + this->neuroLexId_.set (std::move (x)); + } + // networkTypes // @@ -13690,6 +14745,36 @@ namespace neuroml2 this->extracellularProperties_.set (std::move (x)); } + const Population::neuroLexId_optional& Population:: + neuroLexId () const + { + return this->neuroLexId_; + } + + Population::neuroLexId_optional& Population:: + neuroLexId () + { + return this->neuroLexId_; + } + + void Population:: + neuroLexId (const neuroLexId_type& x) + { + this->neuroLexId_.set (x); + } + + void Population:: + neuroLexId (const neuroLexId_optional& x) + { + this->neuroLexId_ = x; + } + + void Population:: + neuroLexId (::std::unique_ptr< neuroLexId_type > x) + { + this->neuroLexId_.set (std::move (x)); + } + // populationTypes // @@ -14235,6 +15320,36 @@ namespace neuroml2 // SynapticConnection // + const SynapticConnection::neuroLexId_optional& SynapticConnection:: + neuroLexId () const + { + return this->neuroLexId_; + } + + SynapticConnection::neuroLexId_optional& SynapticConnection:: + neuroLexId () + { + return this->neuroLexId_; + } + + void SynapticConnection:: + neuroLexId (const neuroLexId_type& x) + { + this->neuroLexId_.set (x); + } + + void SynapticConnection:: + neuroLexId (const neuroLexId_optional& x) + { + this->neuroLexId_ = x; + } + + void SynapticConnection:: + neuroLexId (::std::unique_ptr< neuroLexId_type > x) + { + this->neuroLexId_.set (std::move (x)); + } + const SynapticConnection::from_type& SynapticConnection:: from () const { @@ -14457,6 +15572,36 @@ namespace neuroml2 // BaseConnection // + const BaseConnection::neuroLexId_optional& BaseConnection:: + neuroLexId () const + { + return this->neuroLexId_; + } + + BaseConnection::neuroLexId_optional& BaseConnection:: + neuroLexId () + { + return this->neuroLexId_; + } + + void BaseConnection:: + neuroLexId (const neuroLexId_type& x) + { + this->neuroLexId_.set (x); + } + + void BaseConnection:: + neuroLexId (const neuroLexId_optional& x) + { + this->neuroLexId_ = x; + } + + void BaseConnection:: + neuroLexId (::std::unique_ptr< neuroLexId_type > x) + { + this->neuroLexId_.set (std::move (x)); + } + // BaseConnectionOldFormat // @@ -15273,30 +16418,6 @@ namespace neuroml2 // Input // - const Input::id_type& Input:: - id () const - { - return this->id_.get (); - } - - Input::id_type& Input:: - id () - { - return this->id_.get (); - } - - void Input:: - id (const id_type& x) - { - this->id_.set (x); - } - - void Input:: - id (::std::unique_ptr< id_type > x) - { - this->id_.set (std::move (x)); - } - const Input::target_type& Input:: target () const { @@ -17674,6 +18795,78 @@ namespace neuroml2 { } + // Nml2PopulationReferencePath + // + + Nml2PopulationReferencePath:: + Nml2PopulationReferencePath () + : ::xml_schema::string () + { + } + + Nml2PopulationReferencePath:: + Nml2PopulationReferencePath (const char* _xsd_string_base) + : ::xml_schema::string (_xsd_string_base) + { + } + + Nml2PopulationReferencePath:: + Nml2PopulationReferencePath (const ::std::string& _xsd_string_base) + : ::xml_schema::string (_xsd_string_base) + { + } + + Nml2PopulationReferencePath:: + Nml2PopulationReferencePath (const ::xml_schema::string& _xsd_string_base) + : ::xml_schema::string (_xsd_string_base) + { + } + + Nml2PopulationReferencePath:: + Nml2PopulationReferencePath (const Nml2PopulationReferencePath& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (x, f, c) + { + } + + Nml2PopulationReferencePath:: + Nml2PopulationReferencePath (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (e, f, c) + { + } + + Nml2PopulationReferencePath:: + Nml2PopulationReferencePath (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (a, f, c) + { + } + + Nml2PopulationReferencePath:: + Nml2PopulationReferencePath (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (s, e, f, c) + { + } + + Nml2PopulationReferencePath* Nml2PopulationReferencePath:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class Nml2PopulationReferencePath (*this, f, c); + } + + Nml2PopulationReferencePath:: + ~Nml2PopulationReferencePath () + { + } + // NonNegativeInteger // @@ -17943,13 +19136,79 @@ namespace neuroml2 { } + // BaseWithoutId + // + + BaseWithoutId:: + BaseWithoutId () + : ::xml_schema::type () + { + } + + BaseWithoutId:: + BaseWithoutId (const BaseWithoutId& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c) + { + } + + BaseWithoutId:: + BaseWithoutId (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f, c) + { + } + + BaseWithoutId:: + BaseWithoutId (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (a, f, c) + { + } + + BaseWithoutId:: + BaseWithoutId (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (s, e, f, c) + { + } + + BaseWithoutId* BaseWithoutId:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class BaseWithoutId (*this, f, c); + } + + BaseWithoutId:: + ~BaseWithoutId () + { + } + + bool + operator== (const BaseWithoutId&, const BaseWithoutId&) + { + return true; + } + + bool + operator!= (const BaseWithoutId& x, const BaseWithoutId& y) + { + return !(x == y); + } + // Property // Property:: Property (const tag_type& tag, const value_type& value) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), tag_ (tag, this), value_ (value, this) { @@ -17959,7 +19218,7 @@ namespace neuroml2 Property (const Property& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), tag_ (x.tag_, f, this), value_ (x.value_, f, this) { @@ -17969,7 +19228,7 @@ namespace neuroml2 Property (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), tag_ (this), value_ (this) { @@ -18030,7 +19289,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->tag_ = x.tag_; this->value_ = x.value_; } @@ -18066,7 +19325,7 @@ namespace neuroml2 Annotation:: Annotation () - : ::xml_schema::type () + : ::neuroml2::BaseWithoutId () { } @@ -18074,7 +19333,7 @@ namespace neuroml2 Annotation (const Annotation& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c) + : ::neuroml2::BaseWithoutId (x, f, c) { } @@ -18082,7 +19341,7 @@ namespace neuroml2 Annotation (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c) + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c) { if ((f & ::xml_schema::flags::base) == 0) { @@ -18117,18 +19376,6 @@ namespace neuroml2 { } - bool - operator== (const Annotation&, const Annotation&) - { - return true; - } - - bool - operator!= (const Annotation& x, const Annotation& y) - { - return !(x == y); - } - // ComponentType // @@ -18137,6 +19384,7 @@ namespace neuroml2 : ::xml_schema::type (), Property_ (this), Parameter_ (this), + DerivedParameter_ (this), Constant_ (this), Exposure_ (this), Requirement_ (this), @@ -18155,6 +19403,7 @@ namespace neuroml2 : ::xml_schema::type (x, f, c), Property_ (x.Property_, f, this), Parameter_ (x.Parameter_, f, this), + DerivedParameter_ (x.DerivedParameter_, f, this), Constant_ (x.Constant_, f, this), Exposure_ (x.Exposure_, f, this), Requirement_ (x.Requirement_, f, this), @@ -18173,6 +19422,7 @@ namespace neuroml2 : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), Property_ (this), Parameter_ (this), + DerivedParameter_ (this), Constant_ (this), Exposure_ (this), Requirement_ (this), @@ -18221,6 +19471,17 @@ namespace neuroml2 continue; } + // DerivedParameter + // + if (n.name () == "DerivedParameter" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< DerivedParameter_type > r ( + DerivedParameter_traits::create (i, f, this)); + + this->DerivedParameter_.push_back (::std::move (r)); + continue; + } + // Constant // if (n.name () == "Constant" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") @@ -18327,6 +19588,7 @@ namespace neuroml2 static_cast< ::xml_schema::type& > (*this) = x; this->Property_ = x.Property_; this->Parameter_ = x.Parameter_; + this->DerivedParameter_ = x.DerivedParameter_; this->Constant_ = x.Constant_; this->Exposure_ = x.Exposure_; this->Requirement_ = x.Requirement_; @@ -18354,6 +19616,9 @@ namespace neuroml2 if (!(x.Parameter () == y.Parameter ())) return false; + if (!(x.DerivedParameter () == y.DerivedParameter ())) + return false; + if (!(x.Constant () == y.Constant ())) return false; @@ -18394,7 +19659,7 @@ namespace neuroml2 Constant (const name_type& name, const dimension_type& dimension, const value_type& value) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), name_ (name, this), dimension_ (dimension, this), value_ (value, this), @@ -18406,7 +19671,7 @@ namespace neuroml2 Constant (const Constant& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), name_ (x.name_, f, this), dimension_ (x.dimension_, f, this), value_ (x.value_, f, this), @@ -18418,7 +19683,7 @@ namespace neuroml2 Constant (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), name_ (this), dimension_ (this), value_ (this), @@ -18500,7 +19765,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->name_ = x.name_; this->dimension_ = x.dimension_; this->value_ = x.value_; @@ -18545,7 +19810,7 @@ namespace neuroml2 Exposure:: Exposure (const name_type& name, const dimension_type& dimension) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), name_ (name, this), dimension_ (dimension, this), description_ (this) @@ -18556,7 +19821,7 @@ namespace neuroml2 Exposure (const Exposure& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), name_ (x.name_, f, this), dimension_ (x.dimension_, f, this), description_ (x.description_, f, this) @@ -18567,7 +19832,7 @@ namespace neuroml2 Exposure (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), name_ (this), dimension_ (this), description_ (this) @@ -18635,7 +19900,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->name_ = x.name_; this->dimension_ = x.dimension_; this->description_ = x.description_; @@ -18676,7 +19941,7 @@ namespace neuroml2 NamedDimensionalType:: NamedDimensionalType (const name_type& name, const dimension_type& dimension) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), name_ (name, this), dimension_ (dimension, this), description_ (this) @@ -18687,7 +19952,7 @@ namespace neuroml2 NamedDimensionalType (const NamedDimensionalType& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), name_ (x.name_, f, this), dimension_ (x.dimension_, f, this), description_ (x.description_, f, this) @@ -18698,7 +19963,7 @@ namespace neuroml2 NamedDimensionalType (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), name_ (this), dimension_ (this), description_ (this) @@ -18766,7 +20031,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->name_ = x.name_; this->dimension_ = x.dimension_; this->description_ = x.description_; @@ -18807,7 +20072,7 @@ namespace neuroml2 NamedDimensionalVariable:: NamedDimensionalVariable (const name_type& name, const dimension_type& dimension) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), name_ (name, this), dimension_ (dimension, this), description_ (this), @@ -18819,7 +20084,7 @@ namespace neuroml2 NamedDimensionalVariable (const NamedDimensionalVariable& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), name_ (x.name_, f, this), dimension_ (x.dimension_, f, this), description_ (x.description_, f, this), @@ -18831,7 +20096,7 @@ namespace neuroml2 NamedDimensionalVariable (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), name_ (this), dimension_ (this), description_ (this), @@ -18906,7 +20171,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->name_ = x.name_; this->dimension_ = x.dimension_; this->description_ = x.description_; @@ -18984,6 +20249,114 @@ namespace neuroml2 { } + // DerivedParameter + // + + DerivedParameter:: + DerivedParameter (const name_type& name, + const dimension_type& dimension, + const value_type& value) + : ::neuroml2::NamedDimensionalType (name, + dimension), + value_ (value, this) + { + } + + DerivedParameter:: + DerivedParameter (const DerivedParameter& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::neuroml2::NamedDimensionalType (x, f, c), + value_ (x.value_, f, this) + { + } + + DerivedParameter:: + DerivedParameter (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::neuroml2::NamedDimensionalType (e, f | ::xml_schema::flags::base, c), + value_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, false, true); + this->parse (p, f); + } + } + + void DerivedParameter:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + this->::neuroml2::NamedDimensionalType::parse (p, f); + + p.reset_attributes (); + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "value" && n.namespace_ ().empty ()) + { + this->value_.set (value_traits::create (i, f, this)); + continue; + } + } + + if (!value_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "value", + ""); + } + } + + DerivedParameter* DerivedParameter:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class DerivedParameter (*this, f, c); + } + + DerivedParameter& DerivedParameter:: + operator= (const DerivedParameter& x) + { + if (this != &x) + { + static_cast< ::neuroml2::NamedDimensionalType& > (*this) = x; + this->value_ = x.value_; + } + + return *this; + } + + DerivedParameter:: + ~DerivedParameter () + { + } + + bool + operator== (const DerivedParameter& x, const DerivedParameter& y) + { + if (!(static_cast< const ::neuroml2::NamedDimensionalType& > (x) == + static_cast< const ::neuroml2::NamedDimensionalType& > (y))) + return false; + + if (!(x.value () == y.value ())) + return false; + + return true; + } + + bool + operator!= (const DerivedParameter& x, const DerivedParameter& y) + { + return !(x == y); + } + // LEMS_Property // @@ -19250,7 +20623,11 @@ namespace neuroml2 StateVariable_ (this), DerivedVariable_ (this), ConditionalDerivedVariable_ (this), - TimeDerivative_ (this) + TimeDerivative_ (this), + OnStart_ (this), + OnEvent_ (this), + OnCondition_ (this), + Regime_ (this) { } @@ -19262,7 +20639,11 @@ namespace neuroml2 StateVariable_ (x.StateVariable_, f, this), DerivedVariable_ (x.DerivedVariable_, f, this), ConditionalDerivedVariable_ (x.ConditionalDerivedVariable_, f, this), - TimeDerivative_ (x.TimeDerivative_, f, this) + TimeDerivative_ (x.TimeDerivative_, f, this), + OnStart_ (x.OnStart_, f, this), + OnEvent_ (x.OnEvent_, f, this), + OnCondition_ (x.OnCondition_, f, this), + Regime_ (x.Regime_, f, this) { } @@ -19274,7 +20655,11 @@ namespace neuroml2 StateVariable_ (this), DerivedVariable_ (this), ConditionalDerivedVariable_ (this), - TimeDerivative_ (this) + TimeDerivative_ (this), + OnStart_ (this), + OnEvent_ (this), + OnCondition_ (this), + Regime_ (this) { if ((f & ::xml_schema::flags::base) == 0) { @@ -19337,6 +20722,53 @@ namespace neuroml2 continue; } + // OnStart + // + if (n.name () == "OnStart" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< OnStart_type > r ( + OnStart_traits::create (i, f, this)); + + if (!this->OnStart_) + { + this->OnStart_.set (::std::move (r)); + continue; + } + } + + // OnEvent + // + if (n.name () == "OnEvent" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< OnEvent_type > r ( + OnEvent_traits::create (i, f, this)); + + this->OnEvent_.push_back (::std::move (r)); + continue; + } + + // OnCondition + // + if (n.name () == "OnCondition" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< OnCondition_type > r ( + OnCondition_traits::create (i, f, this)); + + this->OnCondition_.push_back (::std::move (r)); + continue; + } + + // Regime + // + if (n.name () == "Regime" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< Regime_type > r ( + Regime_traits::create (i, f, this)); + + this->Regime_.push_back (::std::move (r)); + continue; + } + break; } } @@ -19358,6 +20790,10 @@ namespace neuroml2 this->DerivedVariable_ = x.DerivedVariable_; this->ConditionalDerivedVariable_ = x.ConditionalDerivedVariable_; this->TimeDerivative_ = x.TimeDerivative_; + this->OnStart_ = x.OnStart_; + this->OnEvent_ = x.OnEvent_; + this->OnCondition_ = x.OnCondition_; + this->Regime_ = x.Regime_; } return *this; @@ -19383,6 +20819,18 @@ namespace neuroml2 if (!(x.TimeDerivative () == y.TimeDerivative ())) return false; + if (!(x.OnStart () == y.OnStart ())) + return false; + + if (!(x.OnEvent () == y.OnEvent ())) + return false; + + if (!(x.OnCondition () == y.OnCondition ())) + return false; + + if (!(x.Regime () == y.Regime ())) + return false; + return true; } @@ -19877,6 +21325,1063 @@ namespace neuroml2 return !(x == y); } + // OnStart + // + + OnStart:: + OnStart () + : ::xml_schema::type (), + StateAssignment_ (this) + { + } + + OnStart:: + OnStart (const OnStart& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + StateAssignment_ (x.StateAssignment_, f, this) + { + } + + OnStart:: + OnStart (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + StateAssignment_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false); + this->parse (p, f); + } + } + + void OnStart:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_content (); p.next_content (false)) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // StateAssignment + // + if (n.name () == "StateAssignment" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< StateAssignment_type > r ( + StateAssignment_traits::create (i, f, this)); + + this->StateAssignment_.push_back (::std::move (r)); + continue; + } + + break; + } + } + + OnStart* OnStart:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class OnStart (*this, f, c); + } + + OnStart& OnStart:: + operator= (const OnStart& x) + { + if (this != &x) + { + static_cast< ::xml_schema::type& > (*this) = x; + this->StateAssignment_ = x.StateAssignment_; + } + + return *this; + } + + OnStart:: + ~OnStart () + { + } + + bool + operator== (const OnStart& x, const OnStart& y) + { + if (!(x.StateAssignment () == y.StateAssignment ())) + return false; + + return true; + } + + bool + operator!= (const OnStart& x, const OnStart& y) + { + return !(x == y); + } + + // StateAssignment + // + + StateAssignment:: + StateAssignment (const variable_type& variable, + const value_type& value) + : ::xml_schema::type (), + variable_ (variable, this), + value_ (value, this) + { + } + + StateAssignment:: + StateAssignment (const StateAssignment& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + variable_ (x.variable_, f, this), + value_ (x.value_, f, this) + { + } + + StateAssignment:: + StateAssignment (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + variable_ (this), + value_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, false, true); + this->parse (p, f); + } + } + + void StateAssignment:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "variable" && n.namespace_ ().empty ()) + { + this->variable_.set (variable_traits::create (i, f, this)); + continue; + } + + if (n.name () == "value" && n.namespace_ ().empty ()) + { + this->value_.set (value_traits::create (i, f, this)); + continue; + } + } + + if (!variable_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "variable", + ""); + } + + if (!value_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "value", + ""); + } + } + + StateAssignment* StateAssignment:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class StateAssignment (*this, f, c); + } + + StateAssignment& StateAssignment:: + operator= (const StateAssignment& x) + { + if (this != &x) + { + static_cast< ::xml_schema::type& > (*this) = x; + this->variable_ = x.variable_; + this->value_ = x.value_; + } + + return *this; + } + + StateAssignment:: + ~StateAssignment () + { + } + + bool + operator== (const StateAssignment& x, const StateAssignment& y) + { + if (!(x.variable () == y.variable ())) + return false; + + if (!(x.value () == y.value ())) + return false; + + return true; + } + + bool + operator!= (const StateAssignment& x, const StateAssignment& y) + { + return !(x == y); + } + + // OnEvent + // + + OnEvent:: + OnEvent (const port_type& port) + : ::xml_schema::type (), + StateAssignment_ (this), + EventOut_ (this), + port_ (port, this) + { + } + + OnEvent:: + OnEvent (const OnEvent& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + StateAssignment_ (x.StateAssignment_, f, this), + EventOut_ (x.EventOut_, f, this), + port_ (x.port_, f, this) + { + } + + OnEvent:: + OnEvent (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + StateAssignment_ (this), + EventOut_ (this), + port_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true); + this->parse (p, f); + } + } + + void OnEvent:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_content (); p.next_content (false)) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // StateAssignment + // + if (n.name () == "StateAssignment" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< StateAssignment_type > r ( + StateAssignment_traits::create (i, f, this)); + + this->StateAssignment_.push_back (::std::move (r)); + continue; + } + + // EventOut + // + if (n.name () == "EventOut" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< EventOut_type > r ( + EventOut_traits::create (i, f, this)); + + this->EventOut_.push_back (::std::move (r)); + continue; + } + + break; + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "port" && n.namespace_ ().empty ()) + { + this->port_.set (port_traits::create (i, f, this)); + continue; + } + } + + if (!port_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "port", + ""); + } + } + + OnEvent* OnEvent:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class OnEvent (*this, f, c); + } + + OnEvent& OnEvent:: + operator= (const OnEvent& x) + { + if (this != &x) + { + static_cast< ::xml_schema::type& > (*this) = x; + this->StateAssignment_ = x.StateAssignment_; + this->EventOut_ = x.EventOut_; + this->port_ = x.port_; + } + + return *this; + } + + OnEvent:: + ~OnEvent () + { + } + + bool + operator== (const OnEvent& x, const OnEvent& y) + { + if (!(x.StateAssignment () == y.StateAssignment ())) + return false; + + if (!(x.EventOut () == y.EventOut ())) + return false; + + if (!(x.port () == y.port ())) + return false; + + return true; + } + + bool + operator!= (const OnEvent& x, const OnEvent& y) + { + return !(x == y); + } + + // EventOut + // + + EventOut:: + EventOut (const port_type& port) + : ::xml_schema::type (), + port_ (port, this) + { + } + + EventOut:: + EventOut (const EventOut& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + port_ (x.port_, f, this) + { + } + + EventOut:: + EventOut (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + port_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, false, true); + this->parse (p, f); + } + } + + void EventOut:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "port" && n.namespace_ ().empty ()) + { + this->port_.set (port_traits::create (i, f, this)); + continue; + } + } + + if (!port_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "port", + ""); + } + } + + EventOut* EventOut:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class EventOut (*this, f, c); + } + + EventOut& EventOut:: + operator= (const EventOut& x) + { + if (this != &x) + { + static_cast< ::xml_schema::type& > (*this) = x; + this->port_ = x.port_; + } + + return *this; + } + + EventOut:: + ~EventOut () + { + } + + bool + operator== (const EventOut& x, const EventOut& y) + { + if (!(x.port () == y.port ())) + return false; + + return true; + } + + bool + operator!= (const EventOut& x, const EventOut& y) + { + return !(x == y); + } + + // OnCondition + // + + OnCondition:: + OnCondition (const test_type& test) + : ::xml_schema::type (), + StateAssignment_ (this), + EventOut_ (this), + Transition_ (this), + test_ (test, this) + { + } + + OnCondition:: + OnCondition (const OnCondition& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + StateAssignment_ (x.StateAssignment_, f, this), + EventOut_ (x.EventOut_, f, this), + Transition_ (x.Transition_, f, this), + test_ (x.test_, f, this) + { + } + + OnCondition:: + OnCondition (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + StateAssignment_ (this), + EventOut_ (this), + Transition_ (this), + test_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true); + this->parse (p, f); + } + } + + void OnCondition:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_content (); p.next_content (false)) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // StateAssignment + // + if (n.name () == "StateAssignment" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< StateAssignment_type > r ( + StateAssignment_traits::create (i, f, this)); + + this->StateAssignment_.push_back (::std::move (r)); + continue; + } + + // EventOut + // + if (n.name () == "EventOut" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< EventOut_type > r ( + EventOut_traits::create (i, f, this)); + + this->EventOut_.push_back (::std::move (r)); + continue; + } + + // Transition + // + if (n.name () == "Transition" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< Transition_type > r ( + Transition_traits::create (i, f, this)); + + if (!this->Transition_) + { + this->Transition_.set (::std::move (r)); + continue; + } + } + + break; + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "test" && n.namespace_ ().empty ()) + { + this->test_.set (test_traits::create (i, f, this)); + continue; + } + } + + if (!test_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "test", + ""); + } + } + + OnCondition* OnCondition:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class OnCondition (*this, f, c); + } + + OnCondition& OnCondition:: + operator= (const OnCondition& x) + { + if (this != &x) + { + static_cast< ::xml_schema::type& > (*this) = x; + this->StateAssignment_ = x.StateAssignment_; + this->EventOut_ = x.EventOut_; + this->Transition_ = x.Transition_; + this->test_ = x.test_; + } + + return *this; + } + + OnCondition:: + ~OnCondition () + { + } + + bool + operator== (const OnCondition& x, const OnCondition& y) + { + if (!(x.StateAssignment () == y.StateAssignment ())) + return false; + + if (!(x.EventOut () == y.EventOut ())) + return false; + + if (!(x.Transition () == y.Transition ())) + return false; + + if (!(x.test () == y.test ())) + return false; + + return true; + } + + bool + operator!= (const OnCondition& x, const OnCondition& y) + { + return !(x == y); + } + + // Transition + // + + Transition:: + Transition (const regime_type& regime) + : ::xml_schema::type (), + regime_ (regime, this) + { + } + + Transition:: + Transition (const Transition& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + regime_ (x.regime_, f, this) + { + } + + Transition:: + Transition (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + regime_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, false, true); + this->parse (p, f); + } + } + + void Transition:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "regime" && n.namespace_ ().empty ()) + { + this->regime_.set (regime_traits::create (i, f, this)); + continue; + } + } + + if (!regime_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "regime", + ""); + } + } + + Transition* Transition:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class Transition (*this, f, c); + } + + Transition& Transition:: + operator= (const Transition& x) + { + if (this != &x) + { + static_cast< ::xml_schema::type& > (*this) = x; + this->regime_ = x.regime_; + } + + return *this; + } + + Transition:: + ~Transition () + { + } + + bool + operator== (const Transition& x, const Transition& y) + { + if (!(x.regime () == y.regime ())) + return false; + + return true; + } + + bool + operator!= (const Transition& x, const Transition& y) + { + return !(x == y); + } + + // Regime + // + + Regime:: + Regime (const name_type& name) + : ::xml_schema::type (), + TimeDerivative_ (this), + OnEntry_ (this), + OnCondition_ (this), + name_ (name, this), + initial_ (this) + { + } + + Regime:: + Regime (const Regime& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + TimeDerivative_ (x.TimeDerivative_, f, this), + OnEntry_ (x.OnEntry_, f, this), + OnCondition_ (x.OnCondition_, f, this), + name_ (x.name_, f, this), + initial_ (x.initial_, f, this) + { + } + + Regime:: + Regime (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + TimeDerivative_ (this), + OnEntry_ (this), + OnCondition_ (this), + name_ (this), + initial_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true); + this->parse (p, f); + } + } + + void Regime:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_content (); p.next_content (false)) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // TimeDerivative + // + if (n.name () == "TimeDerivative" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< TimeDerivative_type > r ( + TimeDerivative_traits::create (i, f, this)); + + this->TimeDerivative_.push_back (::std::move (r)); + continue; + } + + // OnEntry + // + if (n.name () == "OnEntry" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< OnEntry_type > r ( + OnEntry_traits::create (i, f, this)); + + if (!this->OnEntry_) + { + this->OnEntry_.set (::std::move (r)); + continue; + } + } + + // OnCondition + // + if (n.name () == "OnCondition" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< OnCondition_type > r ( + OnCondition_traits::create (i, f, this)); + + this->OnCondition_.push_back (::std::move (r)); + continue; + } + + break; + } + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "name" && n.namespace_ ().empty ()) + { + this->name_.set (name_traits::create (i, f, this)); + continue; + } + + if (n.name () == "initial" && n.namespace_ ().empty ()) + { + this->initial_.set (initial_traits::create (i, f, this)); + continue; + } + } + + if (!name_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "name", + ""); + } + } + + Regime* Regime:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class Regime (*this, f, c); + } + + Regime& Regime:: + operator= (const Regime& x) + { + if (this != &x) + { + static_cast< ::xml_schema::type& > (*this) = x; + this->TimeDerivative_ = x.TimeDerivative_; + this->OnEntry_ = x.OnEntry_; + this->OnCondition_ = x.OnCondition_; + this->name_ = x.name_; + this->initial_ = x.initial_; + } + + return *this; + } + + Regime:: + ~Regime () + { + } + + bool + operator== (const Regime& x, const Regime& y) + { + if (!(x.TimeDerivative () == y.TimeDerivative ())) + return false; + + if (!(x.OnEntry () == y.OnEntry ())) + return false; + + if (!(x.OnCondition () == y.OnCondition ())) + return false; + + if (!(x.name () == y.name ())) + return false; + + if (!(x.initial () == y.initial ())) + return false; + + return true; + } + + bool + operator!= (const Regime& x, const Regime& y) + { + return !(x == y); + } + + // OnEntry + // + + OnEntry:: + OnEntry () + : ::xml_schema::type (), + StateAssignment_ (this) + { + } + + OnEntry:: + OnEntry (const OnEntry& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (x, f, c), + StateAssignment_ (x.StateAssignment_, f, this) + { + } + + OnEntry:: + OnEntry (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + StateAssignment_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false); + this->parse (p, f); + } + } + + void OnEntry:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + for (; p.more_content (); p.next_content (false)) + { + const ::xercesc::DOMElement& i (p.cur_element ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + // StateAssignment + // + if (n.name () == "StateAssignment" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< StateAssignment_type > r ( + StateAssignment_traits::create (i, f, this)); + + this->StateAssignment_.push_back (::std::move (r)); + continue; + } + + break; + } + } + + OnEntry* OnEntry:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class OnEntry (*this, f, c); + } + + OnEntry& OnEntry:: + operator= (const OnEntry& x) + { + if (this != &x) + { + static_cast< ::xml_schema::type& > (*this) = x; + this->StateAssignment_ = x.StateAssignment_; + } + + return *this; + } + + OnEntry:: + ~OnEntry () + { + } + + bool + operator== (const OnEntry& x, const OnEntry& y) + { + if (!(x.StateAssignment () == y.StateAssignment ())) + return false; + + return true; + } + + bool + operator!= (const OnEntry& x, const OnEntry& y) + { + return !(x == y); + } + + // TrueOrFalse + // + + TrueOrFalse:: + TrueOrFalse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (e, f, c) + { + _xsd_TrueOrFalse_convert (); + } + + TrueOrFalse:: + TrueOrFalse (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (a, f, c) + { + _xsd_TrueOrFalse_convert (); + } + + TrueOrFalse:: + TrueOrFalse (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::xml_schema::string (s, e, f, c) + { + _xsd_TrueOrFalse_convert (); + } + + TrueOrFalse* TrueOrFalse:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class TrueOrFalse (*this, f, c); + } + + TrueOrFalse::value TrueOrFalse:: + _xsd_TrueOrFalse_convert () const + { + ::xsd::cxx::tree::enum_comparator< char > c (_xsd_TrueOrFalse_literals_); + const value* i (::std::lower_bound ( + _xsd_TrueOrFalse_indexes_, + _xsd_TrueOrFalse_indexes_ + 2, + *this, + c)); + + if (i == _xsd_TrueOrFalse_indexes_ + 2 || _xsd_TrueOrFalse_literals_[*i] != *this) + { + throw ::xsd::cxx::tree::unexpected_enumerator < char > (*this); + } + + return *i; + } + + const char* const TrueOrFalse:: + _xsd_TrueOrFalse_literals_[2] = + { + "true", + "false" + }; + + const TrueOrFalse::value TrueOrFalse:: + _xsd_TrueOrFalse_indexes_[2] = + { + ::neuroml2::TrueOrFalse::false_, + ::neuroml2::TrueOrFalse::true_ + }; + // ZeroToOne // @@ -19931,96 +22436,6 @@ namespace neuroml2 { } - // BaseWithoutId - // - - BaseWithoutId:: - BaseWithoutId () - : ::xml_schema::type (), - neuroLexId_ (this) - { - } - - BaseWithoutId:: - BaseWithoutId (const BaseWithoutId& x, - ::xml_schema::flags f, - ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), - neuroLexId_ (x.neuroLexId_, f, this) - { - } - - BaseWithoutId:: - BaseWithoutId (const ::xercesc::DOMElement& e, - ::xml_schema::flags f, - ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), - neuroLexId_ (this) - { - if ((f & ::xml_schema::flags::base) == 0) - { - ::xsd::cxx::xml::dom::parser< char > p (e, false, false, true); - this->parse (p, f); - } - } - - void BaseWithoutId:: - parse (::xsd::cxx::xml::dom::parser< char >& p, - ::xml_schema::flags f) - { - while (p.more_attributes ()) - { - const ::xercesc::DOMAttr& i (p.next_attribute ()); - const ::xsd::cxx::xml::qualified_name< char > n ( - ::xsd::cxx::xml::dom::name< char > (i)); - - if (n.name () == "neuroLexId" && n.namespace_ ().empty ()) - { - this->neuroLexId_.set (neuroLexId_traits::create (i, f, this)); - continue; - } - } - } - - BaseWithoutId* BaseWithoutId:: - _clone (::xml_schema::flags f, - ::xml_schema::container* c) const - { - return new class BaseWithoutId (*this, f, c); - } - - BaseWithoutId& BaseWithoutId:: - operator= (const BaseWithoutId& x) - { - if (this != &x) - { - static_cast< ::xml_schema::type& > (*this) = x; - this->neuroLexId_ = x.neuroLexId_; - } - - return *this; - } - - BaseWithoutId:: - ~BaseWithoutId () - { - } - - bool - operator== (const BaseWithoutId& x, const BaseWithoutId& y) - { - if (!(x.neuroLexId () == y.neuroLexId ())) - return false; - - return true; - } - - bool - operator!= (const BaseWithoutId& x, const BaseWithoutId& y) - { - return !(x == y); - } - // Base // @@ -20058,10 +22473,6 @@ namespace neuroml2 parse (::xsd::cxx::xml::dom::parser< char >& p, ::xml_schema::flags f) { - this->::neuroml2::BaseWithoutId::parse (p, f); - - p.reset_attributes (); - while (p.more_attributes ()) { const ::xercesc::DOMAttr& i (p.next_attribute ()); @@ -20110,10 +22521,6 @@ namespace neuroml2 bool operator== (const Base& x, const Base& y) { - if (!(static_cast< const ::neuroml2::BaseWithoutId& > (x) == - static_cast< const ::neuroml2::BaseWithoutId& > (y))) - return false; - if (!(x.id () == y.id ())) return false; @@ -20334,6 +22741,7 @@ namespace neuroml2 fitzHughNagumoCell_ (this), fitzHughNagumo1969Cell_ (this), pinskyRinzelCA3Cell_ (this), + hindmarshRose1984Cell_ (this), pulseGenerator_ (this), pulseGeneratorDL_ (this), sineGenerator_ (this), @@ -20409,6 +22817,7 @@ namespace neuroml2 fitzHughNagumoCell_ (x.fitzHughNagumoCell_, f, this), fitzHughNagumo1969Cell_ (x.fitzHughNagumo1969Cell_, f, this), pinskyRinzelCA3Cell_ (x.pinskyRinzelCA3Cell_, f, this), + hindmarshRose1984Cell_ (x.hindmarshRose1984Cell_, f, this), pulseGenerator_ (x.pulseGenerator_, f, this), pulseGeneratorDL_ (x.pulseGeneratorDL_, f, this), sineGenerator_ (x.sineGenerator_, f, this), @@ -20484,6 +22893,7 @@ namespace neuroml2 fitzHughNagumoCell_ (this), fitzHughNagumo1969Cell_ (this), pinskyRinzelCA3Cell_ (this), + hindmarshRose1984Cell_ (this), pulseGenerator_ (this), pulseGeneratorDL_ (this), sineGenerator_ (this), @@ -20921,6 +23331,17 @@ namespace neuroml2 continue; } + // hindmarshRose1984Cell + // + if (n.name () == "hindmarshRose1984Cell" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") + { + ::std::unique_ptr< hindmarshRose1984Cell_type > r ( + hindmarshRose1984Cell_traits::create (i, f, this)); + + this->hindmarshRose1984Cell_.push_back (::std::move (r)); + continue; + } + // pulseGenerator // if (n.name () == "pulseGenerator" && n.namespace_ () == "http://www.neuroml.org/schema/neuroml2") @@ -21325,6 +23746,7 @@ namespace neuroml2 this->fitzHughNagumoCell_ = x.fitzHughNagumoCell_; this->fitzHughNagumo1969Cell_ = x.fitzHughNagumo1969Cell_; this->pinskyRinzelCA3Cell_ = x.pinskyRinzelCA3Cell_; + this->hindmarshRose1984Cell_ = x.hindmarshRose1984Cell_; this->pulseGenerator_ = x.pulseGenerator_; this->pulseGeneratorDL_ = x.pulseGeneratorDL_; this->sineGenerator_ = x.sineGenerator_; @@ -21479,6 +23901,9 @@ namespace neuroml2 if (!(x.pinskyRinzelCA3Cell () == y.pinskyRinzelCA3Cell ())) return false; + if (!(x.hindmarshRose1984Cell () == y.hindmarshRose1984Cell ())) + return false; + if (!(x.pulseGenerator () == y.pulseGenerator ())) return false; @@ -21687,7 +24112,8 @@ namespace neuroml2 IonChannelScalable:: IonChannelScalable (const id_type& id) : ::neuroml2::Standalone (id), - q10ConductanceScaling_ (this) + q10ConductanceScaling_ (this), + neuroLexId_ (this) { } @@ -21696,7 +24122,8 @@ namespace neuroml2 ::xml_schema::flags f, ::xml_schema::container* c) : ::neuroml2::Standalone (x, f, c), - q10ConductanceScaling_ (x.q10ConductanceScaling_, f, this) + q10ConductanceScaling_ (x.q10ConductanceScaling_, f, this), + neuroLexId_ (x.neuroLexId_, f, this) { } @@ -21705,7 +24132,8 @@ namespace neuroml2 ::xml_schema::flags f, ::xml_schema::container* c) : ::neuroml2::Standalone (e, f | ::xml_schema::flags::base, c), - q10ConductanceScaling_ (this) + q10ConductanceScaling_ (this), + neuroLexId_ (this) { if ((f & ::xml_schema::flags::base) == 0) { @@ -21739,6 +24167,21 @@ namespace neuroml2 break; } + + p.reset_attributes (); + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "neuroLexId" && n.namespace_ ().empty ()) + { + this->neuroLexId_.set (neuroLexId_traits::create (i, f, this)); + continue; + } + } } IonChannelScalable* IonChannelScalable:: @@ -21755,6 +24198,7 @@ namespace neuroml2 { static_cast< ::neuroml2::Standalone& > (*this) = x; this->q10ConductanceScaling_ = x.q10ConductanceScaling_; + this->neuroLexId_ = x.neuroLexId_; } return *this; @@ -21775,6 +24219,9 @@ namespace neuroml2 if (!(x.q10ConductanceScaling () == y.q10ConductanceScaling ())) return false; + if (!(x.neuroLexId () == y.neuroLexId ())) + return false; + return true; } @@ -21792,7 +24239,8 @@ namespace neuroml2 : ::neuroml2::Standalone (id), gateKS_ (this), species_ (this), - conductance_ (this) + conductance_ (this), + neuroLexId_ (this) { } @@ -21803,7 +24251,8 @@ namespace neuroml2 : ::neuroml2::Standalone (x, f, c), gateKS_ (x.gateKS_, f, this), species_ (x.species_, f, this), - conductance_ (x.conductance_, f, this) + conductance_ (x.conductance_, f, this), + neuroLexId_ (x.neuroLexId_, f, this) { } @@ -21814,7 +24263,8 @@ namespace neuroml2 : ::neuroml2::Standalone (e, f | ::xml_schema::flags::base, c), gateKS_ (this), species_ (this), - conductance_ (this) + conductance_ (this), + neuroLexId_ (this) { if ((f & ::xml_schema::flags::base) == 0) { @@ -21868,6 +24318,12 @@ namespace neuroml2 this->conductance_.set (conductance_traits::create (i, f, this)); continue; } + + if (n.name () == "neuroLexId" && n.namespace_ ().empty ()) + { + this->neuroLexId_.set (neuroLexId_traits::create (i, f, this)); + continue; + } } } @@ -21887,6 +24343,7 @@ namespace neuroml2 this->gateKS_ = x.gateKS_; this->species_ = x.species_; this->conductance_ = x.conductance_; + this->neuroLexId_ = x.neuroLexId_; } return *this; @@ -21913,6 +24370,9 @@ namespace neuroml2 if (!(x.conductance () == y.conductance ())) return false; + if (!(x.neuroLexId () == y.neuroLexId ())) + return false; + return true; } @@ -22418,7 +24878,7 @@ namespace neuroml2 Q10ConductanceScaling:: Q10ConductanceScaling (const q10Factor_type& q10Factor, const experimentalTemp_type& experimentalTemp) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), q10Factor_ (q10Factor, this), experimentalTemp_ (experimentalTemp, this) { @@ -22428,7 +24888,7 @@ namespace neuroml2 Q10ConductanceScaling (const Q10ConductanceScaling& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), q10Factor_ (x.q10Factor_, f, this), experimentalTemp_ (x.experimentalTemp_, f, this) { @@ -22438,7 +24898,7 @@ namespace neuroml2 Q10ConductanceScaling (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), q10Factor_ (this), experimentalTemp_ (this) { @@ -22499,7 +24959,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->q10Factor_ = x.q10Factor_; this->experimentalTemp_ = x.experimentalTemp_; } @@ -25683,7 +28143,7 @@ namespace neuroml2 HHRate:: HHRate (const type_type& type) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), type_ (type, this), rate_ (this), midpoint_ (this), @@ -25695,7 +28155,7 @@ namespace neuroml2 HHRate (const HHRate& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), type_ (x.type_, f, this), rate_ (x.rate_, f, this), midpoint_ (x.midpoint_, f, this), @@ -25707,7 +28167,7 @@ namespace neuroml2 HHRate (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), type_ (this), rate_ (this), midpoint_ (this), @@ -25775,7 +28235,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->type_ = x.type_; this->rate_ = x.rate_; this->midpoint_ = x.midpoint_; @@ -25819,7 +28279,7 @@ namespace neuroml2 HHVariable:: HHVariable (const type_type& type) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), type_ (type, this), rate_ (this), midpoint_ (this), @@ -25831,7 +28291,7 @@ namespace neuroml2 HHVariable (const HHVariable& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), type_ (x.type_, f, this), rate_ (x.rate_, f, this), midpoint_ (x.midpoint_, f, this), @@ -25843,7 +28303,7 @@ namespace neuroml2 HHVariable (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), type_ (this), rate_ (this), midpoint_ (this), @@ -25911,7 +28371,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->type_ = x.type_; this->rate_ = x.rate_; this->midpoint_ = x.midpoint_; @@ -25955,7 +28415,7 @@ namespace neuroml2 HHTime:: HHTime (const type_type& type) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), type_ (type, this), rate_ (this), midpoint_ (this), @@ -25968,7 +28428,7 @@ namespace neuroml2 HHTime (const HHTime& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), type_ (x.type_, f, this), rate_ (x.rate_, f, this), midpoint_ (x.midpoint_, f, this), @@ -25981,7 +28441,7 @@ namespace neuroml2 HHTime (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), type_ (this), rate_ (this), midpoint_ (this), @@ -26056,7 +28516,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->type_ = x.type_; this->rate_ = x.rate_; this->midpoint_ = x.midpoint_; @@ -26177,9 +28637,178 @@ namespace neuroml2 continue; } - if (n.name () == "shellThickness" && n.namespace_ ().empty ()) + if (n.name () == "shellThickness" && n.namespace_ ().empty ()) + { + this->shellThickness_.set (shellThickness_traits::create (i, f, this)); + continue; + } + } + + if (!ion_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "ion", + ""); + } + + if (!restingConc_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "restingConc", + ""); + } + + if (!decayConstant_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "decayConstant", + ""); + } + + if (!shellThickness_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "shellThickness", + ""); + } + } + + DecayingPoolConcentrationModel* DecayingPoolConcentrationModel:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class DecayingPoolConcentrationModel (*this, f, c); + } + + DecayingPoolConcentrationModel& DecayingPoolConcentrationModel:: + operator= (const DecayingPoolConcentrationModel& x) + { + if (this != &x) + { + static_cast< ::neuroml2::Standalone& > (*this) = x; + this->ion_ = x.ion_; + this->restingConc_ = x.restingConc_; + this->decayConstant_ = x.decayConstant_; + this->shellThickness_ = x.shellThickness_; + } + + return *this; + } + + DecayingPoolConcentrationModel:: + ~DecayingPoolConcentrationModel () + { + } + + bool + operator== (const DecayingPoolConcentrationModel& x, const DecayingPoolConcentrationModel& y) + { + if (!(static_cast< const ::neuroml2::Standalone& > (x) == + static_cast< const ::neuroml2::Standalone& > (y))) + return false; + + if (!(x.ion () == y.ion ())) + return false; + + if (!(x.restingConc () == y.restingConc ())) + return false; + + if (!(x.decayConstant () == y.decayConstant ())) + return false; + + if (!(x.shellThickness () == y.shellThickness ())) + return false; + + return true; + } + + bool + operator!= (const DecayingPoolConcentrationModel& x, const DecayingPoolConcentrationModel& y) + { + return !(x == y); + } + + // FixedFactorConcentrationModel + // + + FixedFactorConcentrationModel:: + FixedFactorConcentrationModel (const id_type& id, + const ion_type& ion, + const restingConc_type& restingConc, + const decayConstant_type& decayConstant, + const rho_type& rho) + : ::neuroml2::Standalone (id), + ion_ (ion, this), + restingConc_ (restingConc, this), + decayConstant_ (decayConstant, this), + rho_ (rho, this) + { + } + + FixedFactorConcentrationModel:: + FixedFactorConcentrationModel (const FixedFactorConcentrationModel& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::neuroml2::Standalone (x, f, c), + ion_ (x.ion_, f, this), + restingConc_ (x.restingConc_, f, this), + decayConstant_ (x.decayConstant_, f, this), + rho_ (x.rho_, f, this) + { + } + + FixedFactorConcentrationModel:: + FixedFactorConcentrationModel (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::neuroml2::Standalone (e, f | ::xml_schema::flags::base, c), + ion_ (this), + restingConc_ (this), + decayConstant_ (this), + rho_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true); + this->parse (p, f); + } + } + + void FixedFactorConcentrationModel:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + this->::neuroml2::Standalone::parse (p, f); + + p.reset_attributes (); + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "ion" && n.namespace_ ().empty ()) + { + this->ion_.set (ion_traits::create (i, f, this)); + continue; + } + + if (n.name () == "restingConc" && n.namespace_ ().empty ()) + { + this->restingConc_.set (restingConc_traits::create (i, f, this)); + continue; + } + + if (n.name () == "decayConstant" && n.namespace_ ().empty ()) + { + this->decayConstant_.set (decayConstant_traits::create (i, f, this)); + continue; + } + + if (n.name () == "rho" && n.namespace_ ().empty ()) { - this->shellThickness_.set (shellThickness_traits::create (i, f, this)); + this->rho_.set (rho_traits::create (i, f, this)); continue; } } @@ -26205,23 +28834,23 @@ namespace neuroml2 ""); } - if (!shellThickness_.present ()) + if (!rho_.present ()) { throw ::xsd::cxx::tree::expected_attribute< char > ( - "shellThickness", + "rho", ""); } } - DecayingPoolConcentrationModel* DecayingPoolConcentrationModel:: + FixedFactorConcentrationModel* FixedFactorConcentrationModel:: _clone (::xml_schema::flags f, ::xml_schema::container* c) const { - return new class DecayingPoolConcentrationModel (*this, f, c); + return new class FixedFactorConcentrationModel (*this, f, c); } - DecayingPoolConcentrationModel& DecayingPoolConcentrationModel:: - operator= (const DecayingPoolConcentrationModel& x) + FixedFactorConcentrationModel& FixedFactorConcentrationModel:: + operator= (const FixedFactorConcentrationModel& x) { if (this != &x) { @@ -26229,19 +28858,19 @@ namespace neuroml2 this->ion_ = x.ion_; this->restingConc_ = x.restingConc_; this->decayConstant_ = x.decayConstant_; - this->shellThickness_ = x.shellThickness_; + this->rho_ = x.rho_; } return *this; } - DecayingPoolConcentrationModel:: - ~DecayingPoolConcentrationModel () + FixedFactorConcentrationModel:: + ~FixedFactorConcentrationModel () { } bool - operator== (const DecayingPoolConcentrationModel& x, const DecayingPoolConcentrationModel& y) + operator== (const FixedFactorConcentrationModel& x, const FixedFactorConcentrationModel& y) { if (!(static_cast< const ::neuroml2::Standalone& > (x) == static_cast< const ::neuroml2::Standalone& > (y))) @@ -26256,56 +28885,43 @@ namespace neuroml2 if (!(x.decayConstant () == y.decayConstant ())) return false; - if (!(x.shellThickness () == y.shellThickness ())) + if (!(x.rho () == y.rho ())) return false; return true; } bool - operator!= (const DecayingPoolConcentrationModel& x, const DecayingPoolConcentrationModel& y) + operator!= (const FixedFactorConcentrationModel& x, const FixedFactorConcentrationModel& y) { return !(x == y); } - // FixedFactorConcentrationModel + // BaseSynapse // - FixedFactorConcentrationModel:: - FixedFactorConcentrationModel (const id_type& id, - const ion_type& ion, - const restingConc_type& restingConc, - const decayConstant_type& decayConstant, - const rho_type& rho) + BaseSynapse:: + BaseSynapse (const id_type& id) : ::neuroml2::Standalone (id), - ion_ (ion, this), - restingConc_ (restingConc, this), - decayConstant_ (decayConstant, this), - rho_ (rho, this) + neuroLexId_ (this) { } - FixedFactorConcentrationModel:: - FixedFactorConcentrationModel (const FixedFactorConcentrationModel& x, - ::xml_schema::flags f, - ::xml_schema::container* c) + BaseSynapse:: + BaseSynapse (const BaseSynapse& x, + ::xml_schema::flags f, + ::xml_schema::container* c) : ::neuroml2::Standalone (x, f, c), - ion_ (x.ion_, f, this), - restingConc_ (x.restingConc_, f, this), - decayConstant_ (x.decayConstant_, f, this), - rho_ (x.rho_, f, this) + neuroLexId_ (x.neuroLexId_, f, this) { } - FixedFactorConcentrationModel:: - FixedFactorConcentrationModel (const ::xercesc::DOMElement& e, - ::xml_schema::flags f, - ::xml_schema::container* c) + BaseSynapse:: + BaseSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) : ::neuroml2::Standalone (e, f | ::xml_schema::flags::base, c), - ion_ (this), - restingConc_ (this), - decayConstant_ (this), - rho_ (this) + neuroLexId_ (this) { if ((f & ::xml_schema::flags::base) == 0) { @@ -26314,7 +28930,7 @@ namespace neuroml2 } } - void FixedFactorConcentrationModel:: + void BaseSynapse:: parse (::xsd::cxx::xml::dom::parser< char >& p, ::xml_schema::flags f) { @@ -26328,152 +28944,57 @@ namespace neuroml2 const ::xsd::cxx::xml::qualified_name< char > n ( ::xsd::cxx::xml::dom::name< char > (i)); - if (n.name () == "ion" && n.namespace_ ().empty ()) - { - this->ion_.set (ion_traits::create (i, f, this)); - continue; - } - - if (n.name () == "restingConc" && n.namespace_ ().empty ()) - { - this->restingConc_.set (restingConc_traits::create (i, f, this)); - continue; - } - - if (n.name () == "decayConstant" && n.namespace_ ().empty ()) - { - this->decayConstant_.set (decayConstant_traits::create (i, f, this)); - continue; - } - - if (n.name () == "rho" && n.namespace_ ().empty ()) + if (n.name () == "neuroLexId" && n.namespace_ ().empty ()) { - this->rho_.set (rho_traits::create (i, f, this)); + this->neuroLexId_.set (neuroLexId_traits::create (i, f, this)); continue; } } - - if (!ion_.present ()) - { - throw ::xsd::cxx::tree::expected_attribute< char > ( - "ion", - ""); - } - - if (!restingConc_.present ()) - { - throw ::xsd::cxx::tree::expected_attribute< char > ( - "restingConc", - ""); - } - - if (!decayConstant_.present ()) - { - throw ::xsd::cxx::tree::expected_attribute< char > ( - "decayConstant", - ""); - } - - if (!rho_.present ()) - { - throw ::xsd::cxx::tree::expected_attribute< char > ( - "rho", - ""); - } } - FixedFactorConcentrationModel* FixedFactorConcentrationModel:: + BaseSynapse* BaseSynapse:: _clone (::xml_schema::flags f, ::xml_schema::container* c) const { - return new class FixedFactorConcentrationModel (*this, f, c); + return new class BaseSynapse (*this, f, c); } - FixedFactorConcentrationModel& FixedFactorConcentrationModel:: - operator= (const FixedFactorConcentrationModel& x) + BaseSynapse& BaseSynapse:: + operator= (const BaseSynapse& x) { if (this != &x) { static_cast< ::neuroml2::Standalone& > (*this) = x; - this->ion_ = x.ion_; - this->restingConc_ = x.restingConc_; - this->decayConstant_ = x.decayConstant_; - this->rho_ = x.rho_; + this->neuroLexId_ = x.neuroLexId_; } return *this; } - FixedFactorConcentrationModel:: - ~FixedFactorConcentrationModel () + BaseSynapse:: + ~BaseSynapse () { } bool - operator== (const FixedFactorConcentrationModel& x, const FixedFactorConcentrationModel& y) + operator== (const BaseSynapse& x, const BaseSynapse& y) { if (!(static_cast< const ::neuroml2::Standalone& > (x) == static_cast< const ::neuroml2::Standalone& > (y))) return false; - if (!(x.ion () == y.ion ())) - return false; - - if (!(x.restingConc () == y.restingConc ())) - return false; - - if (!(x.decayConstant () == y.decayConstant ())) - return false; - - if (!(x.rho () == y.rho ())) + if (!(x.neuroLexId () == y.neuroLexId ())) return false; return true; } bool - operator!= (const FixedFactorConcentrationModel& x, const FixedFactorConcentrationModel& y) + operator!= (const BaseSynapse& x, const BaseSynapse& y) { return !(x == y); } - // BaseSynapse - // - - BaseSynapse:: - BaseSynapse (const id_type& id) - : ::neuroml2::Standalone (id) - { - } - - BaseSynapse:: - BaseSynapse (const BaseSynapse& x, - ::xml_schema::flags f, - ::xml_schema::container* c) - : ::neuroml2::Standalone (x, f, c) - { - } - - BaseSynapse:: - BaseSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f, - ::xml_schema::container* c) - : ::neuroml2::Standalone (e, f, c) - { - } - - BaseSynapse* BaseSynapse:: - _clone (::xml_schema::flags f, - ::xml_schema::container* c) const - { - return new class BaseSynapse (*this, f, c); - } - - BaseSynapse:: - ~BaseSynapse () - { - } - // BaseVoltageDepSynapse // @@ -28275,7 +30796,7 @@ namespace neuroml2 const blockConcentration_type& blockConcentration, const scalingConc_type& scalingConc, const scalingVolt_type& scalingVolt) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), type_ (type, this), species_ (species, this), blockConcentration_ (blockConcentration, this), @@ -28288,7 +30809,7 @@ namespace neuroml2 BlockMechanism (const BlockMechanism& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), type_ (x.type_, f, this), species_ (x.species_, f, this), blockConcentration_ (x.blockConcentration_, f, this), @@ -28301,7 +30822,7 @@ namespace neuroml2 BlockMechanism (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), type_ (this), species_ (this), blockConcentration_ (this), @@ -28404,7 +30925,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->type_ = x.type_; this->species_ = x.species_; this->blockConcentration_ = x.blockConcentration_; @@ -28524,7 +31045,7 @@ namespace neuroml2 PlasticityMechanism (const type_type& type, const initReleaseProb_type& initReleaseProb, const tauRec_type& tauRec) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), type_ (type, this), initReleaseProb_ (initReleaseProb, this), tauRec_ (tauRec, this), @@ -28536,7 +31057,7 @@ namespace neuroml2 PlasticityMechanism (const PlasticityMechanism& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), type_ (x.type_, f, this), initReleaseProb_ (x.initReleaseProb_, f, this), tauRec_ (x.tauRec_, f, this), @@ -28548,7 +31069,7 @@ namespace neuroml2 PlasticityMechanism (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), type_ (this), initReleaseProb_ (this), tauRec_ (this), @@ -28630,7 +31151,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->type_ = x.type_; this->initReleaseProb_ = x.initReleaseProb_; this->tauRec_ = x.tauRec_; @@ -28674,7 +31195,8 @@ namespace neuroml2 BaseCell:: BaseCell (const id_type& id) - : ::neuroml2::Standalone (id) + : ::neuroml2::Standalone (id), + neuroLexId_ (this) { } @@ -28682,7 +31204,8 @@ namespace neuroml2 BaseCell (const BaseCell& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::neuroml2::Standalone (x, f, c) + : ::neuroml2::Standalone (x, f, c), + neuroLexId_ (x.neuroLexId_, f, this) { } @@ -28690,8 +31213,36 @@ namespace neuroml2 BaseCell (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::neuroml2::Standalone (e, f, c) + : ::neuroml2::Standalone (e, f | ::xml_schema::flags::base, c), + neuroLexId_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true); + this->parse (p, f); + } + } + + void BaseCell:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) { + this->::neuroml2::Standalone::parse (p, f); + + p.reset_attributes (); + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "neuroLexId" && n.namespace_ ().empty ()) + { + this->neuroLexId_.set (neuroLexId_traits::create (i, f, this)); + continue; + } + } } BaseCell* BaseCell:: @@ -28701,11 +31252,42 @@ namespace neuroml2 return new class BaseCell (*this, f, c); } + BaseCell& BaseCell:: + operator= (const BaseCell& x) + { + if (this != &x) + { + static_cast< ::neuroml2::Standalone& > (*this) = x; + this->neuroLexId_ = x.neuroLexId_; + } + + return *this; + } + BaseCell:: ~BaseCell () { } + bool + operator== (const BaseCell& x, const BaseCell& y) + { + if (!(static_cast< const ::neuroml2::Standalone& > (x) == + static_cast< const ::neuroml2::Standalone& > (y))) + return false; + + if (!(x.neuroLexId () == y.neuroLexId ())) + return false; + + return true; + } + + bool + operator!= (const BaseCell& x, const BaseCell& y) + { + return !(x == y); + } + // IafTauCell // @@ -31028,6 +33610,324 @@ namespace neuroml2 return !(x == y); } + // HindmarshRose1984Cell + // + + HindmarshRose1984Cell:: + HindmarshRose1984Cell (const id_type& id, + const C_type& C, + const a_type& a, + const b_type& b, + const c_type& c, + const d_type& d, + const s_type& s, + const x1_type& x1, + const r_type& r, + const x0_type& x0, + const y0_type& y0, + const z0_type& z0, + const v_scaling_type& v_scaling) + : ::neuroml2::BaseCellMembPotCap (id, + C), + a_ (a, this), + b_ (b, this), + c_ (c, this), + d_ (d, this), + s_ (s, this), + x1_ (x1, this), + r_ (r, this), + x0_ (x0, this), + y0_ (y0, this), + z0_ (z0, this), + v_scaling_ (v_scaling, this) + { + } + + HindmarshRose1984Cell:: + HindmarshRose1984Cell (const HindmarshRose1984Cell& x, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::neuroml2::BaseCellMembPotCap (x, f, c), + a_ (x.a_, f, this), + b_ (x.b_, f, this), + c_ (x.c_, f, this), + d_ (x.d_, f, this), + s_ (x.s_, f, this), + x1_ (x.x1_, f, this), + r_ (x.r_, f, this), + x0_ (x.x0_, f, this), + y0_ (x.y0_, f, this), + z0_ (x.z0_, f, this), + v_scaling_ (x.v_scaling_, f, this) + { + } + + HindmarshRose1984Cell:: + HindmarshRose1984Cell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f, + ::xml_schema::container* c) + : ::neuroml2::BaseCellMembPotCap (e, f | ::xml_schema::flags::base, c), + a_ (this), + b_ (this), + c_ (this), + d_ (this), + s_ (this), + x1_ (this), + r_ (this), + x0_ (this), + y0_ (this), + z0_ (this), + v_scaling_ (this) + { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true); + this->parse (p, f); + } + } + + void HindmarshRose1984Cell:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + this->::neuroml2::BaseCellMembPotCap::parse (p, f); + + p.reset_attributes (); + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "a" && n.namespace_ ().empty ()) + { + this->a_.set (a_traits::create (i, f, this)); + continue; + } + + if (n.name () == "b" && n.namespace_ ().empty ()) + { + this->b_.set (b_traits::create (i, f, this)); + continue; + } + + if (n.name () == "c" && n.namespace_ ().empty ()) + { + this->c_.set (c_traits::create (i, f, this)); + continue; + } + + if (n.name () == "d" && n.namespace_ ().empty ()) + { + this->d_.set (d_traits::create (i, f, this)); + continue; + } + + if (n.name () == "s" && n.namespace_ ().empty ()) + { + this->s_.set (s_traits::create (i, f, this)); + continue; + } + + if (n.name () == "x1" && n.namespace_ ().empty ()) + { + this->x1_.set (x1_traits::create (i, f, this)); + continue; + } + + if (n.name () == "r" && n.namespace_ ().empty ()) + { + this->r_.set (r_traits::create (i, f, this)); + continue; + } + + if (n.name () == "x0" && n.namespace_ ().empty ()) + { + this->x0_.set (x0_traits::create (i, f, this)); + continue; + } + + if (n.name () == "y0" && n.namespace_ ().empty ()) + { + this->y0_.set (y0_traits::create (i, f, this)); + continue; + } + + if (n.name () == "z0" && n.namespace_ ().empty ()) + { + this->z0_.set (z0_traits::create (i, f, this)); + continue; + } + + if (n.name () == "v_scaling" && n.namespace_ ().empty ()) + { + this->v_scaling_.set (v_scaling_traits::create (i, f, this)); + continue; + } + } + + if (!a_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "a", + ""); + } + + if (!b_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "b", + ""); + } + + if (!c_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "c", + ""); + } + + if (!d_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "d", + ""); + } + + if (!s_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "s", + ""); + } + + if (!x1_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "x1", + ""); + } + + if (!r_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "r", + ""); + } + + if (!x0_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "x0", + ""); + } + + if (!y0_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "y0", + ""); + } + + if (!z0_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "z0", + ""); + } + + if (!v_scaling_.present ()) + { + throw ::xsd::cxx::tree::expected_attribute< char > ( + "v_scaling", + ""); + } + } + + HindmarshRose1984Cell* HindmarshRose1984Cell:: + _clone (::xml_schema::flags f, + ::xml_schema::container* c) const + { + return new class HindmarshRose1984Cell (*this, f, c); + } + + HindmarshRose1984Cell& HindmarshRose1984Cell:: + operator= (const HindmarshRose1984Cell& x) + { + if (this != &x) + { + static_cast< ::neuroml2::BaseCellMembPotCap& > (*this) = x; + this->a_ = x.a_; + this->b_ = x.b_; + this->c_ = x.c_; + this->d_ = x.d_; + this->s_ = x.s_; + this->x1_ = x.x1_; + this->r_ = x.r_; + this->x0_ = x.x0_; + this->y0_ = x.y0_; + this->z0_ = x.z0_; + this->v_scaling_ = x.v_scaling_; + } + + return *this; + } + + HindmarshRose1984Cell:: + ~HindmarshRose1984Cell () + { + } + + bool + operator== (const HindmarshRose1984Cell& x, const HindmarshRose1984Cell& y) + { + if (!(static_cast< const ::neuroml2::BaseCellMembPotCap& > (x) == + static_cast< const ::neuroml2::BaseCellMembPotCap& > (y))) + return false; + + if (!(x.a () == y.a ())) + return false; + + if (!(x.b () == y.b ())) + return false; + + if (!(x.c () == y.c ())) + return false; + + if (!(x.d () == y.d ())) + return false; + + if (!(x.s () == y.s ())) + return false; + + if (!(x.x1 () == y.x1 ())) + return false; + + if (!(x.r () == y.r ())) + return false; + + if (!(x.x0 () == y.x0 ())) + return false; + + if (!(x.y0 () == y.y0 ())) + return false; + + if (!(x.z0 () == y.z0 ())) + return false; + + if (!(x.v_scaling () == y.v_scaling ())) + return false; + + return true; + } + + bool + operator!= (const HindmarshRose1984Cell& x, const HindmarshRose1984Cell& y) + { + return !(x == y); + } + // Cell // @@ -31454,10 +34354,6 @@ namespace neuroml2 parse (::xsd::cxx::xml::dom::parser< char >& p, ::xml_schema::flags f) { - this->::neuroml2::BaseWithoutId::parse (p, f); - - p.reset_attributes (); - while (p.more_attributes ()) { const ::xercesc::DOMAttr& i (p.next_attribute ()); @@ -31506,10 +34402,6 @@ namespace neuroml2 bool operator== (const BaseNonNegativeIntegerId& x, const BaseNonNegativeIntegerId& y) { - if (!(static_cast< const ::neuroml2::BaseWithoutId& > (x) == - static_cast< const ::neuroml2::BaseWithoutId& > (y))) - return false; - if (!(x.id () == y.id ())) return false; @@ -31532,7 +34424,8 @@ namespace neuroml2 parent_ (this), proximal_ (this), distal_ (distal, this), - name_ (this) + name_ (this), + neuroLexId_ (this) { } @@ -31543,7 +34436,8 @@ namespace neuroml2 parent_ (this), proximal_ (this), distal_ (std::move (distal), this), - name_ (this) + name_ (this), + neuroLexId_ (this) { } @@ -31555,7 +34449,8 @@ namespace neuroml2 parent_ (x.parent_, f, this), proximal_ (x.proximal_, f, this), distal_ (x.distal_, f, this), - name_ (x.name_, f, this) + name_ (x.name_, f, this), + neuroLexId_ (x.neuroLexId_, f, this) { } @@ -31567,7 +34462,8 @@ namespace neuroml2 parent_ (this), proximal_ (this), distal_ (this), - name_ (this) + name_ (this), + neuroLexId_ (this) { if ((f & ::xml_schema::flags::base) == 0) { @@ -31653,6 +34549,12 @@ namespace neuroml2 this->name_.set (name_traits::create (i, f, this)); continue; } + + if (n.name () == "neuroLexId" && n.namespace_ ().empty ()) + { + this->neuroLexId_.set (neuroLexId_traits::create (i, f, this)); + continue; + } } } @@ -31673,6 +34575,7 @@ namespace neuroml2 this->proximal_ = x.proximal_; this->distal_ = x.distal_; this->name_ = x.name_; + this->neuroLexId_ = x.neuroLexId_; } return *this; @@ -31702,6 +34605,9 @@ namespace neuroml2 if (!(x.name () == y.name ())) return false; + if (!(x.neuroLexId () == y.neuroLexId ())) + return false; + return true; } @@ -31716,7 +34622,7 @@ namespace neuroml2 SegmentParent:: SegmentParent (const segment_type& segment) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), segment_ (segment, this), fractionAlong_ (fractionAlong_default_value (), this) { @@ -31726,7 +34632,7 @@ namespace neuroml2 SegmentParent (const SegmentParent& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), segment_ (x.segment_, f, this), fractionAlong_ (x.fractionAlong_, f, this) { @@ -31736,7 +34642,7 @@ namespace neuroml2 SegmentParent (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), segment_ (this), fractionAlong_ (this) { @@ -31795,7 +34701,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->segment_ = x.segment_; this->fractionAlong_ = x.fractionAlong_; } @@ -31834,7 +34740,7 @@ namespace neuroml2 const y_type& y, const z_type& z, const diameter_type& diameter) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), x_ (x, this), y_ (y, this), z_ (z, this), @@ -31846,7 +34752,7 @@ namespace neuroml2 Point3DWithDiam (const Point3DWithDiam& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), x_ (x.x_, f, this), y_ (x.y_, f, this), z_ (x.z_, f, this), @@ -31858,7 +34764,7 @@ namespace neuroml2 Point3DWithDiam (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), x_ (this), y_ (this), z_ (this), @@ -31947,7 +34853,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->x_ = x.x_; this->y_ = x.y_; this->z_ = x.z_; @@ -31999,7 +34905,8 @@ namespace neuroml2 include_ (this), path_ (this), subTree_ (this), - inhomogeneousParameter_ (this) + inhomogeneousParameter_ (this), + neuroLexId_ (this) { } @@ -32015,7 +34922,8 @@ namespace neuroml2 include_ (x.include_, f, this), path_ (x.path_, f, this), subTree_ (x.subTree_, f, this), - inhomogeneousParameter_ (x.inhomogeneousParameter_, f, this) + inhomogeneousParameter_ (x.inhomogeneousParameter_, f, this), + neuroLexId_ (x.neuroLexId_, f, this) { } @@ -32031,7 +34939,8 @@ namespace neuroml2 include_ (this), path_ (this), subTree_ (this), - inhomogeneousParameter_ (this) + inhomogeneousParameter_ (this), + neuroLexId_ (this) { if ((f & ::xml_schema::flags::base) == 0) { @@ -32148,6 +35057,21 @@ namespace neuroml2 break; } + + p.reset_attributes (); + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "neuroLexId" && n.namespace_ ().empty ()) + { + this->neuroLexId_.set (neuroLexId_traits::create (i, f, this)); + continue; + } + } } SegmentGroup* SegmentGroup:: @@ -32171,6 +35095,7 @@ namespace neuroml2 this->path_ = x.path_; this->subTree_ = x.subTree_; this->inhomogeneousParameter_ = x.inhomogeneousParameter_; + this->neuroLexId_ = x.neuroLexId_; } return *this; @@ -32212,6 +35137,9 @@ namespace neuroml2 if (!(x.inhomogeneousParameter () == y.inhomogeneousParameter ())) return false; + if (!(x.neuroLexId () == y.neuroLexId ())) + return false; + return true; } @@ -32472,7 +35400,7 @@ namespace neuroml2 ProximalDetails:: ProximalDetails (const translationStart_type& translationStart) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), translationStart_ (translationStart, this) { } @@ -32481,7 +35409,7 @@ namespace neuroml2 ProximalDetails (const ProximalDetails& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), translationStart_ (x.translationStart_, f, this) { } @@ -32490,7 +35418,7 @@ namespace neuroml2 ProximalDetails (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), translationStart_ (this) { if ((f & ::xml_schema::flags::base) == 0) @@ -32537,7 +35465,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->translationStart_ = x.translationStart_; } @@ -32569,7 +35497,7 @@ namespace neuroml2 DistalDetails:: DistalDetails (const normalizationEnd_type& normalizationEnd) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), normalizationEnd_ (normalizationEnd, this) { } @@ -32578,7 +35506,7 @@ namespace neuroml2 DistalDetails (const DistalDetails& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), normalizationEnd_ (x.normalizationEnd_, f, this) { } @@ -32587,7 +35515,7 @@ namespace neuroml2 DistalDetails (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), normalizationEnd_ (this) { if ((f & ::xml_schema::flags::base) == 0) @@ -32634,7 +35562,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->normalizationEnd_ = x.normalizationEnd_; } @@ -32666,7 +35594,7 @@ namespace neuroml2 Member:: Member (const segment_type& segment) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), segment_ (segment, this) { } @@ -32675,7 +35603,7 @@ namespace neuroml2 Member (const Member& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), segment_ (x.segment_, f, this) { } @@ -32684,7 +35612,7 @@ namespace neuroml2 Member (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), segment_ (this) { if ((f & ::xml_schema::flags::base) == 0) @@ -32731,7 +35659,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->segment_ = x.segment_; } @@ -32763,7 +35691,7 @@ namespace neuroml2 Include:: Include (const segmentGroup_type& segmentGroup) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), segmentGroup_ (segmentGroup, this) { } @@ -32772,7 +35700,7 @@ namespace neuroml2 Include (const Include& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), segmentGroup_ (x.segmentGroup_, f, this) { } @@ -32781,7 +35709,7 @@ namespace neuroml2 Include (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), segmentGroup_ (this) { if ((f & ::xml_schema::flags::base) == 0) @@ -32828,7 +35756,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->segmentGroup_ = x.segmentGroup_; } @@ -32860,7 +35788,7 @@ namespace neuroml2 Path:: Path () - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), from_ (this), to_ (this) { @@ -32870,7 +35798,7 @@ namespace neuroml2 Path (const Path& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), from_ (x.from_, f, this), to_ (x.to_, f, this) { @@ -32880,7 +35808,7 @@ namespace neuroml2 Path (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), from_ (this), to_ (this) { @@ -32945,7 +35873,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->from_ = x.from_; this->to_ = x.to_; } @@ -32981,7 +35909,7 @@ namespace neuroml2 SubTree:: SubTree () - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), from_ (this), to_ (this) { @@ -32991,7 +35919,7 @@ namespace neuroml2 SubTree (const SubTree& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), from_ (x.from_, f, this), to_ (x.to_, f, this) { @@ -33001,7 +35929,7 @@ namespace neuroml2 SubTree (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), from_ (this), to_ (this) { @@ -33066,7 +35994,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->from_ = x.from_; this->to_ = x.to_; } @@ -33102,7 +36030,7 @@ namespace neuroml2 SegmentEndPoint:: SegmentEndPoint (const segment_type& segment) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), segment_ (segment, this) { } @@ -33111,7 +36039,7 @@ namespace neuroml2 SegmentEndPoint (const SegmentEndPoint& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), segment_ (x.segment_, f, this) { } @@ -33120,7 +36048,7 @@ namespace neuroml2 SegmentEndPoint (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), segment_ (this) { if ((f & ::xml_schema::flags::base) == 0) @@ -33167,7 +36095,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->segment_ = x.segment_; } @@ -33531,7 +36459,7 @@ namespace neuroml2 MembraneProperties:: MembraneProperties () - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), channelPopulation_ (this), channelDensity_ (this), channelDensityVShift_ (this), @@ -33551,7 +36479,7 @@ namespace neuroml2 MembraneProperties (const MembraneProperties& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), channelPopulation_ (x.channelPopulation_, f, this), channelDensity_ (x.channelDensity_, f, this), channelDensityVShift_ (x.channelDensityVShift_, f, this), @@ -33571,7 +36499,7 @@ namespace neuroml2 MembraneProperties (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), channelPopulation_ (this), channelDensity_ (this), channelDensityVShift_ (this), @@ -33750,7 +36678,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->channelPopulation_ = x.channelPopulation_; this->channelDensity_ = x.channelDensity_; this->channelDensityVShift_ = x.channelDensityVShift_; @@ -33932,7 +36860,7 @@ namespace neuroml2 SpikeThresh:: SpikeThresh (const value_type& value) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), value_ (value, this), segmentGroup_ (segmentGroup_default_value (), this) { @@ -33942,7 +36870,7 @@ namespace neuroml2 SpikeThresh (const SpikeThresh& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), value_ (x.value_, f, this), segmentGroup_ (x.segmentGroup_, f, this) { @@ -33952,7 +36880,7 @@ namespace neuroml2 SpikeThresh (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), value_ (this), segmentGroup_ (this) { @@ -34011,7 +36939,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->value_ = x.value_; this->segmentGroup_ = x.segmentGroup_; } @@ -34050,7 +36978,7 @@ namespace neuroml2 SpecificCapacitance:: SpecificCapacitance (const value_type& value) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), value_ (value, this), segmentGroup_ (segmentGroup_default_value (), this) { @@ -34060,7 +36988,7 @@ namespace neuroml2 SpecificCapacitance (const SpecificCapacitance& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), value_ (x.value_, f, this), segmentGroup_ (x.segmentGroup_, f, this) { @@ -34070,7 +36998,7 @@ namespace neuroml2 SpecificCapacitance (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), value_ (this), segmentGroup_ (this) { @@ -34129,7 +37057,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->value_ = x.value_; this->segmentGroup_ = x.segmentGroup_; } @@ -34168,7 +37096,7 @@ namespace neuroml2 InitMembPotential:: InitMembPotential (const value_type& value) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), value_ (value, this), segmentGroup_ (segmentGroup_default_value (), this) { @@ -34178,7 +37106,7 @@ namespace neuroml2 InitMembPotential (const InitMembPotential& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), value_ (x.value_, f, this), segmentGroup_ (x.segmentGroup_, f, this) { @@ -34188,7 +37116,7 @@ namespace neuroml2 InitMembPotential (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), value_ (this), segmentGroup_ (this) { @@ -34247,7 +37175,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->value_ = x.value_; this->segmentGroup_ = x.segmentGroup_; } @@ -34286,7 +37214,7 @@ namespace neuroml2 Resistivity:: Resistivity (const value_type& value) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), value_ (value, this), segmentGroup_ (segmentGroup_default_value (), this) { @@ -34296,7 +37224,7 @@ namespace neuroml2 Resistivity (const Resistivity& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), value_ (x.value_, f, this), segmentGroup_ (x.segmentGroup_, f, this) { @@ -34306,7 +37234,7 @@ namespace neuroml2 Resistivity (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), value_ (this), segmentGroup_ (this) { @@ -34365,7 +37293,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->value_ = x.value_; this->segmentGroup_ = x.segmentGroup_; } @@ -36195,7 +39123,7 @@ namespace neuroml2 InhomogeneousValue:: InhomogeneousValue (const inhomogeneousParameter_type& inhomogeneousParameter, const value_type& value) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), inhomogeneousParameter_ (inhomogeneousParameter, this), value_ (value, this) { @@ -36205,7 +39133,7 @@ namespace neuroml2 InhomogeneousValue (const InhomogeneousValue& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), inhomogeneousParameter_ (x.inhomogeneousParameter_, f, this), value_ (x.value_, f, this) { @@ -36215,7 +39143,7 @@ namespace neuroml2 InhomogeneousValue (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), inhomogeneousParameter_ (this), value_ (this) { @@ -36276,7 +39204,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->inhomogeneousParameter_ = x.inhomogeneousParameter_; this->value_ = x.value_; } @@ -36318,8 +39246,7 @@ namespace neuroml2 const concentrationModel_type& concentrationModel, const initialConcentration_type& initialConcentration, const initialExtConcentration_type& initialExtConcentration) - : ::xml_schema::type (), - id_ (id, this), + : ::neuroml2::Base (id), concentrationModel_ (concentrationModel, this), ion_ (this), initialConcentration_ (initialConcentration, this), @@ -36332,8 +39259,7 @@ namespace neuroml2 Species (const Species& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), - id_ (x.id_, f, this), + : ::neuroml2::Base (x, f, c), concentrationModel_ (x.concentrationModel_, f, this), ion_ (x.ion_, f, this), initialConcentration_ (x.initialConcentration_, f, this), @@ -36346,8 +39272,7 @@ namespace neuroml2 Species (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), - id_ (this), + : ::neuroml2::Base (e, f | ::xml_schema::flags::base, c), concentrationModel_ (this), ion_ (this), initialConcentration_ (this), @@ -36365,18 +39290,16 @@ namespace neuroml2 parse (::xsd::cxx::xml::dom::parser< char >& p, ::xml_schema::flags f) { + this->::neuroml2::Base::parse (p, f); + + p.reset_attributes (); + while (p.more_attributes ()) { const ::xercesc::DOMAttr& i (p.next_attribute ()); const ::xsd::cxx::xml::qualified_name< char > n ( ::xsd::cxx::xml::dom::name< char > (i)); - if (n.name () == "id" && n.namespace_ ().empty ()) - { - this->id_.set (id_traits::create (i, f, this)); - continue; - } - if (n.name () == "concentrationModel" && n.namespace_ ().empty ()) { this->concentrationModel_.set (concentrationModel_traits::create (i, f, this)); @@ -36408,13 +39331,6 @@ namespace neuroml2 } } - if (!id_.present ()) - { - throw ::xsd::cxx::tree::expected_attribute< char > ( - "id", - ""); - } - if (!concentrationModel_.present ()) { throw ::xsd::cxx::tree::expected_attribute< char > ( @@ -36454,8 +39370,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; - this->id_ = x.id_; + static_cast< ::neuroml2::Base& > (*this) = x; this->concentrationModel_ = x.concentrationModel_; this->ion_ = x.ion_; this->initialConcentration_ = x.initialConcentration_; @@ -36474,7 +39389,8 @@ namespace neuroml2 bool operator== (const Species& x, const Species& y) { - if (!(x.id () == y.id ())) + if (!(static_cast< const ::neuroml2::Base& > (x) == + static_cast< const ::neuroml2::Base& > (y))) return false; if (!(x.concentrationModel () == y.concentrationModel ())) @@ -36620,7 +39536,7 @@ namespace neuroml2 IntracellularProperties:: IntracellularProperties () - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), species_ (this), resistivity_ (this) { @@ -36630,7 +39546,7 @@ namespace neuroml2 IntracellularProperties (const IntracellularProperties& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), species_ (x.species_, f, this), resistivity_ (x.resistivity_, f, this) { @@ -36640,7 +39556,7 @@ namespace neuroml2 IntracellularProperties (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), species_ (this), resistivity_ (this) { @@ -36699,7 +39615,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->species_ = x.species_; this->resistivity_ = x.resistivity_; } @@ -36874,8 +39790,8 @@ namespace neuroml2 // ExtracellularPropertiesLocal:: - ExtracellularPropertiesLocal () - : ::xml_schema::type (), + ExtracellularPropertiesLocal (const id_type& id) + : ::neuroml2::Base (id), species_ (this) { } @@ -36884,7 +39800,7 @@ namespace neuroml2 ExtracellularPropertiesLocal (const ExtracellularPropertiesLocal& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::Base (x, f, c), species_ (x.species_, f, this) { } @@ -36893,12 +39809,12 @@ namespace neuroml2 ExtracellularPropertiesLocal (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::Base (e, f | ::xml_schema::flags::base, c), species_ (this) { if ((f & ::xml_schema::flags::base) == 0) { - ::xsd::cxx::xml::dom::parser< char > p (e, true, false, false); + ::xsd::cxx::xml::dom::parser< char > p (e, true, false, true); this->parse (p, f); } } @@ -36907,6 +39823,8 @@ namespace neuroml2 parse (::xsd::cxx::xml::dom::parser< char >& p, ::xml_schema::flags f) { + this->::neuroml2::Base::parse (p, f); + for (; p.more_content (); p.next_content (false)) { const ::xercesc::DOMElement& i (p.cur_element ()); @@ -36940,7 +39858,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::Base& > (*this) = x; this->species_ = x.species_; } @@ -36955,6 +39873,10 @@ namespace neuroml2 bool operator== (const ExtracellularPropertiesLocal& x, const ExtracellularPropertiesLocal& y) { + if (!(static_cast< const ::neuroml2::Base& > (x) == + static_cast< const ::neuroml2::Base& > (y))) + return false; + if (!(x.species () == y.species ())) return false; @@ -40004,7 +42926,8 @@ namespace neuroml2 explicitInput_ (this), inputList_ (this), type_ (this), - temperature_ (this) + temperature_ (this), + neuroLexId_ (this) { } @@ -40025,7 +42948,8 @@ namespace neuroml2 explicitInput_ (x.explicitInput_, f, this), inputList_ (x.inputList_, f, this), type_ (x.type_, f, this), - temperature_ (x.temperature_, f, this) + temperature_ (x.temperature_, f, this), + neuroLexId_ (x.neuroLexId_, f, this) { } @@ -40046,7 +42970,8 @@ namespace neuroml2 explicitInput_ (this), inputList_ (this), type_ (this), - temperature_ (this) + temperature_ (this), + neuroLexId_ (this) { if ((f & ::xml_schema::flags::base) == 0) { @@ -40210,6 +43135,12 @@ namespace neuroml2 this->temperature_.set (temperature_traits::create (i, f, this)); continue; } + + if (n.name () == "neuroLexId" && n.namespace_ ().empty ()) + { + this->neuroLexId_.set (neuroLexId_traits::create (i, f, this)); + continue; + } } } @@ -40239,6 +43170,7 @@ namespace neuroml2 this->inputList_ = x.inputList_; this->type_ = x.type_; this->temperature_ = x.temperature_; + this->neuroLexId_ = x.neuroLexId_; } return *this; @@ -40295,6 +43227,9 @@ namespace neuroml2 if (!(x.temperature () == y.temperature ())) return false; + if (!(x.neuroLexId () == y.neuroLexId ())) + return false; + return true; } @@ -40507,7 +43442,7 @@ namespace neuroml2 SpaceStructure:: SpaceStructure () - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), xSpacing_ (this), ySpacing_ (this), zSpacing_ (this), @@ -40521,7 +43456,7 @@ namespace neuroml2 SpaceStructure (const SpaceStructure& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), xSpacing_ (x.xSpacing_, f, this), ySpacing_ (x.ySpacing_, f, this), zSpacing_ (x.zSpacing_, f, this), @@ -40535,7 +43470,7 @@ namespace neuroml2 SpaceStructure (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), xSpacing_ (this), ySpacing_ (this), zSpacing_ (this), @@ -40625,7 +43560,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->xSpacing_ = x.xSpacing_; this->ySpacing_ = x.ySpacing_; this->zSpacing_ = x.zSpacing_; @@ -40869,7 +43804,8 @@ namespace neuroml2 component_ (component, this), size_ (this), type_ (this), - extracellularProperties_ (this) + extracellularProperties_ (this), + neuroLexId_ (this) { } @@ -40883,7 +43819,8 @@ namespace neuroml2 component_ (x.component_, f, this), size_ (x.size_, f, this), type_ (x.type_, f, this), - extracellularProperties_ (x.extracellularProperties_, f, this) + extracellularProperties_ (x.extracellularProperties_, f, this), + neuroLexId_ (x.neuroLexId_, f, this) { } @@ -40897,7 +43834,8 @@ namespace neuroml2 component_ (this), size_ (this), type_ (this), - extracellularProperties_ (this) + extracellularProperties_ (this), + neuroLexId_ (this) { if ((f & ::xml_schema::flags::base) == 0) { @@ -40977,6 +43915,12 @@ namespace neuroml2 this->extracellularProperties_.set (extracellularProperties_traits::create (i, f, this)); continue; } + + if (n.name () == "neuroLexId" && n.namespace_ ().empty ()) + { + this->neuroLexId_.set (neuroLexId_traits::create (i, f, this)); + continue; + } } if (!component_.present ()) @@ -41006,6 +43950,7 @@ namespace neuroml2 this->size_ = x.size_; this->type_ = x.type_; this->extracellularProperties_ = x.extracellularProperties_; + this->neuroLexId_ = x.neuroLexId_; } return *this; @@ -41041,6 +43986,9 @@ namespace neuroml2 if (!(x.extracellularProperties () == y.extracellularProperties ())) return false; + if (!(x.neuroLexId () == y.neuroLexId ())) + return false; + return true; } @@ -41125,7 +44073,7 @@ namespace neuroml2 Layout:: Layout () - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), random_ (this), grid_ (this), unstructured_ (this), @@ -41137,7 +44085,7 @@ namespace neuroml2 Layout (const Layout& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), random_ (x.random_, f, this), grid_ (x.grid_, f, this), unstructured_ (x.unstructured_, f, this), @@ -41149,7 +44097,7 @@ namespace neuroml2 Layout (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), random_ (this), grid_ (this), unstructured_ (this), @@ -41243,7 +44191,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->random_ = x.random_; this->grid_ = x.grid_; this->unstructured_ = x.unstructured_; @@ -41287,7 +44235,7 @@ namespace neuroml2 UnstructuredLayout:: UnstructuredLayout () - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), number_ (this) { } @@ -41296,7 +44244,7 @@ namespace neuroml2 UnstructuredLayout (const UnstructuredLayout& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), number_ (x.number_, f, this) { } @@ -41305,7 +44253,7 @@ namespace neuroml2 UnstructuredLayout (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), number_ (this) { if ((f & ::xml_schema::flags::base) == 0) @@ -41345,7 +44293,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->number_ = x.number_; } @@ -41377,7 +44325,7 @@ namespace neuroml2 RandomLayout:: RandomLayout () - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), number_ (this), region_ (this) { @@ -41387,7 +44335,7 @@ namespace neuroml2 RandomLayout (const RandomLayout& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), number_ (x.number_, f, this), region_ (x.region_, f, this) { @@ -41397,7 +44345,7 @@ namespace neuroml2 RandomLayout (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), number_ (this), region_ (this) { @@ -41444,7 +44392,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->number_ = x.number_; this->region_ = x.region_; } @@ -41480,7 +44428,7 @@ namespace neuroml2 GridLayout:: GridLayout () - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), xSize_ (this), ySize_ (this), zSize_ (this) @@ -41491,7 +44439,7 @@ namespace neuroml2 GridLayout (const GridLayout& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), xSize_ (x.xSize_, f, this), ySize_ (x.ySize_, f, this), zSize_ (x.zSize_, f, this) @@ -41502,7 +44450,7 @@ namespace neuroml2 GridLayout (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), xSize_ (this), ySize_ (this), zSize_ (this) @@ -41556,7 +44504,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->xSize_ = x.xSize_; this->ySize_ = x.ySize_; this->zSize_ = x.zSize_; @@ -41596,7 +44544,7 @@ namespace neuroml2 Instance:: Instance (const location_type& location) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), location_ (location, this), id_ (this), i_ (this), @@ -41607,7 +44555,7 @@ namespace neuroml2 Instance:: Instance (::std::unique_ptr< location_type > location) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), location_ (std::move (location), this), id_ (this), i_ (this), @@ -41620,7 +44568,7 @@ namespace neuroml2 Instance (const Instance& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), location_ (x.location_, f, this), id_ (x.id_, f, this), i_ (x.i_, f, this), @@ -41633,7 +44581,7 @@ namespace neuroml2 Instance (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), location_ (this), id_ (this), i_ (this), @@ -41725,7 +44673,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->location_ = x.location_; this->id_ = x.id_; this->i_ = x.i_; @@ -41775,7 +44723,7 @@ namespace neuroml2 Location (const x_type& x, const y_type& y, const z_type& z) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), x_ (x, this), y_ (y, this), z_ (z, this) @@ -41786,7 +44734,7 @@ namespace neuroml2 Location (const Location& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), x_ (x.x_, f, this), y_ (x.y_, f, this), z_ (x.z_, f, this) @@ -41797,7 +44745,7 @@ namespace neuroml2 Location (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), x_ (this), y_ (this), z_ (this) @@ -41872,7 +44820,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->x_ = x.x_; this->y_ = x.y_; this->z_ = x.z_; @@ -42029,7 +44977,8 @@ namespace neuroml2 SynapticConnection (const from_type& from, const to_type& to, const synapse_type& synapse) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), + neuroLexId_ (this), from_ (from, this), to_ (to, this), synapse_ (synapse, this), @@ -42041,7 +44990,8 @@ namespace neuroml2 SynapticConnection (const SynapticConnection& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), + neuroLexId_ (x.neuroLexId_, f, this), from_ (x.from_, f, this), to_ (x.to_, f, this), synapse_ (x.synapse_, f, this), @@ -42053,7 +45003,8 @@ namespace neuroml2 SynapticConnection (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), + neuroLexId_ (this), from_ (this), to_ (this), synapse_ (this), @@ -42076,6 +45027,12 @@ namespace neuroml2 const ::xsd::cxx::xml::qualified_name< char > n ( ::xsd::cxx::xml::dom::name< char > (i)); + if (n.name () == "neuroLexId" && n.namespace_ ().empty ()) + { + this->neuroLexId_.set (neuroLexId_traits::create (i, f, this)); + continue; + } + if (n.name () == "from" && n.namespace_ ().empty ()) { this->from_.set (from_traits::create (i, f, this)); @@ -42135,7 +45092,8 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; + this->neuroLexId_ = x.neuroLexId_; this->from_ = x.from_; this->to_ = x.to_; this->synapse_ = x.synapse_; @@ -42153,6 +45111,9 @@ namespace neuroml2 bool operator== (const SynapticConnection& x, const SynapticConnection& y) { + if (!(x.neuroLexId () == y.neuroLexId ())) + return false; + if (!(x.from () == y.from ())) return false; @@ -42461,7 +45422,8 @@ namespace neuroml2 BaseConnection:: BaseConnection (const id_type& id) - : ::neuroml2::BaseNonNegativeIntegerId (id) + : ::neuroml2::BaseNonNegativeIntegerId (id), + neuroLexId_ (this) { } @@ -42469,7 +45431,8 @@ namespace neuroml2 BaseConnection (const BaseConnection& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::neuroml2::BaseNonNegativeIntegerId (x, f, c) + : ::neuroml2::BaseNonNegativeIntegerId (x, f, c), + neuroLexId_ (x.neuroLexId_, f, this) { } @@ -42477,8 +45440,36 @@ namespace neuroml2 BaseConnection (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::neuroml2::BaseNonNegativeIntegerId (e, f, c) + : ::neuroml2::BaseNonNegativeIntegerId (e, f | ::xml_schema::flags::base, c), + neuroLexId_ (this) { + if ((f & ::xml_schema::flags::base) == 0) + { + ::xsd::cxx::xml::dom::parser< char > p (e, false, false, true); + this->parse (p, f); + } + } + + void BaseConnection:: + parse (::xsd::cxx::xml::dom::parser< char >& p, + ::xml_schema::flags f) + { + this->::neuroml2::BaseNonNegativeIntegerId::parse (p, f); + + p.reset_attributes (); + + while (p.more_attributes ()) + { + const ::xercesc::DOMAttr& i (p.next_attribute ()); + const ::xsd::cxx::xml::qualified_name< char > n ( + ::xsd::cxx::xml::dom::name< char > (i)); + + if (n.name () == "neuroLexId" && n.namespace_ ().empty ()) + { + this->neuroLexId_.set (neuroLexId_traits::create (i, f, this)); + continue; + } + } } BaseConnection* BaseConnection:: @@ -42488,11 +45479,42 @@ namespace neuroml2 return new class BaseConnection (*this, f, c); } + BaseConnection& BaseConnection:: + operator= (const BaseConnection& x) + { + if (this != &x) + { + static_cast< ::neuroml2::BaseNonNegativeIntegerId& > (*this) = x; + this->neuroLexId_ = x.neuroLexId_; + } + + return *this; + } + BaseConnection:: ~BaseConnection () { } + bool + operator== (const BaseConnection& x, const BaseConnection& y) + { + if (!(static_cast< const ::neuroml2::BaseNonNegativeIntegerId& > (x) == + static_cast< const ::neuroml2::BaseNonNegativeIntegerId& > (y))) + return false; + + if (!(x.neuroLexId () == y.neuroLexId ())) + return false; + + return true; + } + + bool + operator!= (const BaseConnection& x, const BaseConnection& y) + { + return !(x == y); + } + // BaseConnectionOldFormat // @@ -43910,7 +46932,7 @@ namespace neuroml2 ExplicitInput:: ExplicitInput (const target_type& target, const input_type& input) - : ::xml_schema::type (), + : ::neuroml2::BaseWithoutId (), target_ (target, this), input_ (input, this), destination_ (this) @@ -43921,7 +46943,7 @@ namespace neuroml2 ExplicitInput (const ExplicitInput& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), + : ::neuroml2::BaseWithoutId (x, f, c), target_ (x.target_, f, this), input_ (x.input_, f, this), destination_ (x.destination_, f, this) @@ -43932,7 +46954,7 @@ namespace neuroml2 ExplicitInput (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), + : ::neuroml2::BaseWithoutId (e, f | ::xml_schema::flags::base, c), target_ (this), input_ (this), destination_ (this) @@ -44000,7 +47022,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; + static_cast< ::neuroml2::BaseWithoutId& > (*this) = x; this->target_ = x.target_; this->input_ = x.input_; this->destination_ = x.destination_; @@ -44214,8 +47236,7 @@ namespace neuroml2 Input (const id_type& id, const target_type& target, const destination_type& destination) - : ::xml_schema::type (), - id_ (id, this), + : ::neuroml2::BaseNonNegativeIntegerId (id), target_ (target, this), destination_ (destination, this), segmentId_ (this), @@ -44227,8 +47248,7 @@ namespace neuroml2 Input (const Input& x, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (x, f, c), - id_ (x.id_, f, this), + : ::neuroml2::BaseNonNegativeIntegerId (x, f, c), target_ (x.target_, f, this), destination_ (x.destination_, f, this), segmentId_ (x.segmentId_, f, this), @@ -44240,8 +47260,7 @@ namespace neuroml2 Input (const ::xercesc::DOMElement& e, ::xml_schema::flags f, ::xml_schema::container* c) - : ::xml_schema::type (e, f | ::xml_schema::flags::base, c), - id_ (this), + : ::neuroml2::BaseNonNegativeIntegerId (e, f | ::xml_schema::flags::base, c), target_ (this), destination_ (this), segmentId_ (this), @@ -44258,18 +47277,16 @@ namespace neuroml2 parse (::xsd::cxx::xml::dom::parser< char >& p, ::xml_schema::flags f) { + this->::neuroml2::BaseNonNegativeIntegerId::parse (p, f); + + p.reset_attributes (); + while (p.more_attributes ()) { const ::xercesc::DOMAttr& i (p.next_attribute ()); const ::xsd::cxx::xml::qualified_name< char > n ( ::xsd::cxx::xml::dom::name< char > (i)); - if (n.name () == "id" && n.namespace_ ().empty ()) - { - this->id_.set (id_traits::create (i, f, this)); - continue; - } - if (n.name () == "target" && n.namespace_ ().empty ()) { this->target_.set (target_traits::create (i, f, this)); @@ -44295,13 +47312,6 @@ namespace neuroml2 } } - if (!id_.present ()) - { - throw ::xsd::cxx::tree::expected_attribute< char > ( - "id", - ""); - } - if (!target_.present ()) { throw ::xsd::cxx::tree::expected_attribute< char > ( @@ -44329,8 +47339,7 @@ namespace neuroml2 { if (this != &x) { - static_cast< ::xml_schema::type& > (*this) = x; - this->id_ = x.id_; + static_cast< ::neuroml2::BaseNonNegativeIntegerId& > (*this) = x; this->target_ = x.target_; this->destination_ = x.destination_; this->segmentId_ = x.segmentId_; @@ -44348,7 +47357,8 @@ namespace neuroml2 bool operator== (const Input& x, const Input& y) { - if (!(x.id () == y.id ())) + if (!(static_cast< const ::neuroml2::BaseNonNegativeIntegerId& > (x) == + static_cast< const ::neuroml2::BaseNonNegativeIntegerId& > (y))) return false; if (!(x.target () == y.target ())) @@ -46553,6 +49563,14 @@ namespace neuroml2 return o; } + ::std::ostream& + operator<< (::std::ostream& o, const Nml2PopulationReferencePath& i) + { + o << static_cast< const ::xml_schema::string& > (i); + + return o; + } + ::std::ostream& operator<< (::std::ostream& o, const NonNegativeInteger& i) { @@ -46591,17 +49609,27 @@ namespace neuroml2 return o; } + ::std::ostream& + operator<< (::std::ostream& o, const BaseWithoutId&) + { + return o; + } + ::std::ostream& operator<< (::std::ostream& o, const Property& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "tag: " << i.tag (); o << ::std::endl << "value: " << i.value (); return o; } ::std::ostream& - operator<< (::std::ostream& o, const Annotation&) + operator<< (::std::ostream& o, const Annotation& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + return o; } @@ -46622,6 +49650,13 @@ namespace neuroml2 o << ::std::endl << "Parameter: " << *b; } + for (ComponentType::DerivedParameter_const_iterator + b (i.DerivedParameter ().begin ()), e (i.DerivedParameter ().end ()); + b != e; ++b) + { + o << ::std::endl << "DerivedParameter: " << *b; + } + for (ComponentType::Constant_const_iterator b (i.Constant ().begin ()), e (i.Constant ().end ()); b != e; ++b) @@ -46674,6 +49709,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Constant& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "name: " << i.name (); o << ::std::endl << "dimension: " << i.dimension (); o << ::std::endl << "value: " << i.value (); @@ -46688,6 +49725,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Exposure& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "name: " << i.name (); o << ::std::endl << "dimension: " << i.dimension (); if (i.description ()) @@ -46701,6 +49740,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const NamedDimensionalType& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "name: " << i.name (); o << ::std::endl << "dimension: " << i.dimension (); if (i.description ()) @@ -46714,6 +49755,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const NamedDimensionalVariable& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "name: " << i.name (); o << ::std::endl << "dimension: " << i.dimension (); if (i.description ()) @@ -46737,6 +49780,15 @@ namespace neuroml2 return o; } + ::std::ostream& + operator<< (::std::ostream& o, const DerivedParameter& i) + { + o << static_cast< const ::neuroml2::NamedDimensionalType& > (i); + + o << ::std::endl << "value: " << i.value (); + return o; + } + ::std::ostream& operator<< (::std::ostream& o, const LEMS_Property& i) { @@ -46797,6 +49849,32 @@ namespace neuroml2 o << ::std::endl << "TimeDerivative: " << *b; } + if (i.OnStart ()) + { + o << ::std::endl << "OnStart: " << *i.OnStart (); + } + + for (Dynamics::OnEvent_const_iterator + b (i.OnEvent ().begin ()), e (i.OnEvent ().end ()); + b != e; ++b) + { + o << ::std::endl << "OnEvent: " << *b; + } + + for (Dynamics::OnCondition_const_iterator + b (i.OnCondition ().begin ()), e (i.OnCondition ().end ()); + b != e; ++b) + { + o << ::std::endl << "OnCondition: " << *b; + } + + for (Dynamics::Regime_const_iterator + b (i.Regime ().begin ()), e (i.Regime ().end ()); + b != e; ++b) + { + o << ::std::endl << "Regime: " << *b; + } + return o; } @@ -46862,21 +49940,148 @@ namespace neuroml2 } ::std::ostream& - operator<< (::std::ostream& o, const ZeroToOne& i) + operator<< (::std::ostream& o, const OnStart& i) { - o << static_cast< const ::xsd::cxx::tree::fundamental_base< ::xml_schema::float_, char, ::xml_schema::simple_type >& > (i); + for (OnStart::StateAssignment_const_iterator + b (i.StateAssignment ().begin ()), e (i.StateAssignment ().end ()); + b != e; ++b) + { + o << ::std::endl << "StateAssignment: " << *b; + } return o; } ::std::ostream& - operator<< (::std::ostream& o, const BaseWithoutId& i) + operator<< (::std::ostream& o, const StateAssignment& i) { - if (i.neuroLexId ()) + o << ::std::endl << "variable: " << i.variable (); + o << ::std::endl << "value: " << i.value (); + return o; + } + + ::std::ostream& + operator<< (::std::ostream& o, const OnEvent& i) + { + for (OnEvent::StateAssignment_const_iterator + b (i.StateAssignment ().begin ()), e (i.StateAssignment ().end ()); + b != e; ++b) { - o << ::std::endl << "neuroLexId: " << *i.neuroLexId (); + o << ::std::endl << "StateAssignment: " << *b; + } + + for (OnEvent::EventOut_const_iterator + b (i.EventOut ().begin ()), e (i.EventOut ().end ()); + b != e; ++b) + { + o << ::std::endl << "EventOut: " << *b; + } + + o << ::std::endl << "port: " << i.port (); + return o; + } + + ::std::ostream& + operator<< (::std::ostream& o, const EventOut& i) + { + o << ::std::endl << "port: " << i.port (); + return o; + } + + ::std::ostream& + operator<< (::std::ostream& o, const OnCondition& i) + { + for (OnCondition::StateAssignment_const_iterator + b (i.StateAssignment ().begin ()), e (i.StateAssignment ().end ()); + b != e; ++b) + { + o << ::std::endl << "StateAssignment: " << *b; + } + + for (OnCondition::EventOut_const_iterator + b (i.EventOut ().begin ()), e (i.EventOut ().end ()); + b != e; ++b) + { + o << ::std::endl << "EventOut: " << *b; + } + + if (i.Transition ()) + { + o << ::std::endl << "Transition: " << *i.Transition (); } + o << ::std::endl << "test: " << i.test (); + return o; + } + + ::std::ostream& + operator<< (::std::ostream& o, const Transition& i) + { + o << ::std::endl << "regime: " << i.regime (); + return o; + } + + ::std::ostream& + operator<< (::std::ostream& o, const Regime& i) + { + for (Regime::TimeDerivative_const_iterator + b (i.TimeDerivative ().begin ()), e (i.TimeDerivative ().end ()); + b != e; ++b) + { + o << ::std::endl << "TimeDerivative: " << *b; + } + + if (i.OnEntry ()) + { + o << ::std::endl << "OnEntry: " << *i.OnEntry (); + } + + for (Regime::OnCondition_const_iterator + b (i.OnCondition ().begin ()), e (i.OnCondition ().end ()); + b != e; ++b) + { + o << ::std::endl << "OnCondition: " << *b; + } + + o << ::std::endl << "name: " << i.name (); + if (i.initial ()) + { + o << ::std::endl << "initial: " << *i.initial (); + } + + return o; + } + + ::std::ostream& + operator<< (::std::ostream& o, const OnEntry& i) + { + for (OnEntry::StateAssignment_const_iterator + b (i.StateAssignment ().begin ()), e (i.StateAssignment ().end ()); + b != e; ++b) + { + o << ::std::endl << "StateAssignment: " << *b; + } + + return o; + } + + ::std::ostream& + operator<< (::std::ostream& o, TrueOrFalse::value i) + { + return o << TrueOrFalse::_xsd_TrueOrFalse_literals_[i]; + } + + ::std::ostream& + operator<< (::std::ostream& o, const TrueOrFalse& i) + { + return o << static_cast< const ::xml_schema::string& > (i); + } + + ::std::ostream& + operator<< (::std::ostream& o, const ZeroToOne& i) + { + o << static_cast< const ::xsd::cxx::tree::fundamental_base< ::xml_schema::float_, char, ::xml_schema::simple_type >& > (i); + return o; } @@ -47169,6 +50374,13 @@ namespace neuroml2 o << ::std::endl << "pinskyRinzelCA3Cell: " << *b; } + for (NeuroMLDocument_base::hindmarshRose1984Cell_const_iterator + b (i.hindmarshRose1984Cell ().begin ()), e (i.hindmarshRose1984Cell ().end ()); + b != e; ++b) + { + o << ::std::endl << "hindmarshRose1984Cell: " << *b; + } + for (NeuroMLDocument_base::pulseGenerator_const_iterator b (i.pulseGenerator ().begin ()), e (i.pulseGenerator ().end ()); b != e; ++b) @@ -47415,6 +50627,11 @@ namespace neuroml2 o << ::std::endl << "q10ConductanceScaling: " << *b; } + if (i.neuroLexId ()) + { + o << ::std::endl << "neuroLexId: " << *i.neuroLexId (); + } + return o; } @@ -47440,6 +50657,11 @@ namespace neuroml2 o << ::std::endl << "conductance: " << *i.conductance (); } + if (i.neuroLexId ()) + { + o << ::std::endl << "neuroLexId: " << *i.neuroLexId (); + } + return o; } @@ -47554,6 +50776,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Q10ConductanceScaling& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "q10Factor: " << i.q10Factor (); o << ::std::endl << "experimentalTemp: " << i.experimentalTemp (); return o; @@ -47916,6 +51140,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const HHRate& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "type: " << i.type (); if (i.rate ()) { @@ -47938,6 +51164,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const HHVariable& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "type: " << i.type (); if (i.rate ()) { @@ -47960,6 +51188,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const HHTime& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "type: " << i.type (); if (i.rate ()) { @@ -48013,6 +51243,11 @@ namespace neuroml2 { o << static_cast< const ::neuroml2::Standalone& > (i); + if (i.neuroLexId ()) + { + o << ::std::endl << "neuroLexId: " << *i.neuroLexId (); + } + return o; } @@ -48186,6 +51421,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const BlockMechanism& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "type: " << i.type (); o << ::std::endl << "species: " << i.species (); o << ::std::endl << "blockConcentration: " << i.blockConcentration (); @@ -48209,6 +51446,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const PlasticityMechanism& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "type: " << i.type (); o << ::std::endl << "initReleaseProb: " << i.initReleaseProb (); o << ::std::endl << "tauRec: " << i.tauRec (); @@ -48225,6 +51464,11 @@ namespace neuroml2 { o << static_cast< const ::neuroml2::Standalone& > (i); + if (i.neuroLexId ()) + { + o << ::std::endl << "neuroLexId: " << *i.neuroLexId (); + } + return o; } @@ -48381,6 +51625,25 @@ namespace neuroml2 return o; } + ::std::ostream& + operator<< (::std::ostream& o, const HindmarshRose1984Cell& i) + { + o << static_cast< const ::neuroml2::BaseCellMembPotCap& > (i); + + o << ::std::endl << "a: " << i.a (); + o << ::std::endl << "b: " << i.b (); + o << ::std::endl << "c: " << i.c (); + o << ::std::endl << "d: " << i.d (); + o << ::std::endl << "s: " << i.s (); + o << ::std::endl << "x1: " << i.x1 (); + o << ::std::endl << "r: " << i.r (); + o << ::std::endl << "x0: " << i.x0 (); + o << ::std::endl << "y0: " << i.y0 (); + o << ::std::endl << "z0: " << i.z0 (); + o << ::std::endl << "v_scaling: " << i.v_scaling (); + return o; + } + ::std::ostream& operator<< (::std::ostream& o, const Cell& i) { @@ -48474,12 +51737,19 @@ namespace neuroml2 o << ::std::endl << "name: " << *i.name (); } + if (i.neuroLexId ()) + { + o << ::std::endl << "neuroLexId: " << *i.neuroLexId (); + } + return o; } ::std::ostream& operator<< (::std::ostream& o, const SegmentParent& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "segment: " << i.segment (); o << ::std::endl << "fractionAlong: " << i.fractionAlong (); return o; @@ -48488,6 +51758,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Point3DWithDiam& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "x: " << i.x (); o << ::std::endl << "y: " << i.y (); o << ::std::endl << "z: " << i.z (); @@ -48552,6 +51824,11 @@ namespace neuroml2 o << ::std::endl << "inhomogeneousParameter: " << *b; } + if (i.neuroLexId ()) + { + o << ::std::endl << "neuroLexId: " << *i.neuroLexId (); + } + return o; } @@ -48590,6 +51867,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const ProximalDetails& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "translationStart: " << i.translationStart (); return o; } @@ -48597,6 +51876,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const DistalDetails& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "normalizationEnd: " << i.normalizationEnd (); return o; } @@ -48604,6 +51885,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Member& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "segment: " << i.segment (); return o; } @@ -48611,6 +51894,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Include& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "segmentGroup: " << i.segmentGroup (); return o; } @@ -48618,6 +51903,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Path& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + if (i.from ()) { o << ::std::endl << "from: " << *i.from (); @@ -48634,6 +51921,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const SubTree& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + if (i.from ()) { o << ::std::endl << "from: " << *i.from (); @@ -48650,6 +51939,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const SegmentEndPoint& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "segment: " << i.segment (); return o; } @@ -48695,6 +51986,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const MembraneProperties& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + for (MembraneProperties::channelPopulation_const_iterator b (i.channelPopulation ().begin ()), e (i.channelPopulation ().end ()); b != e; ++b) @@ -48800,6 +52093,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const SpikeThresh& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "value: " << i.value (); o << ::std::endl << "segmentGroup: " << i.segmentGroup (); return o; @@ -48808,6 +52103,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const SpecificCapacitance& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "value: " << i.value (); o << ::std::endl << "segmentGroup: " << i.segmentGroup (); return o; @@ -48816,6 +52113,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const InitMembPotential& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "value: " << i.value (); o << ::std::endl << "segmentGroup: " << i.segmentGroup (); return o; @@ -48824,6 +52123,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Resistivity& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "value: " << i.value (); o << ::std::endl << "segmentGroup: " << i.segmentGroup (); return o; @@ -49034,6 +52335,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const InhomogeneousValue& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "inhomogeneousParameter: " << i.inhomogeneousParameter (); o << ::std::endl << "value: " << i.value (); return o; @@ -49042,7 +52345,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Species& i) { - o << ::std::endl << "id: " << i.id (); + o << static_cast< const ::neuroml2::Base& > (i); + o << ::std::endl << "concentrationModel: " << i.concentrationModel (); if (i.ion ()) { @@ -49067,6 +52371,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const IntracellularProperties& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + for (IntracellularProperties::species_const_iterator b (i.species ().begin ()), e (i.species ().end ()); b != e; ++b) @@ -49110,6 +52416,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const ExtracellularPropertiesLocal& i) { + o << static_cast< const ::neuroml2::Base& > (i); + for (ExtracellularPropertiesLocal::species_const_iterator b (i.species ().begin ()), e (i.species ().end ()); b != e; ++b) @@ -49483,6 +52791,11 @@ namespace neuroml2 o << ::std::endl << "temperature: " << *i.temperature (); } + if (i.neuroLexId ()) + { + o << ::std::endl << "neuroLexId: " << *i.neuroLexId (); + } + return o; } @@ -49519,6 +52832,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const SpaceStructure& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + if (i.xSpacing ()) { o << ::std::endl << "xSpacing: " << *i.xSpacing (); @@ -49598,6 +52913,11 @@ namespace neuroml2 o << ::std::endl << "extracellularProperties: " << *i.extracellularProperties (); } + if (i.neuroLexId ()) + { + o << ::std::endl << "neuroLexId: " << *i.neuroLexId (); + } + return o; } @@ -49616,6 +52936,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Layout& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + if (i.random ()) { o << ::std::endl << "random: " << *i.random (); @@ -49642,6 +52964,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const UnstructuredLayout& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + if (i.number ()) { o << ::std::endl << "number: " << *i.number (); @@ -49653,6 +52977,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const RandomLayout& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + if (i.number ()) { o << ::std::endl << "number: " << *i.number (); @@ -49669,6 +52995,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const GridLayout& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + if (i.xSize ()) { o << ::std::endl << "xSize: " << *i.xSize (); @@ -49690,6 +53018,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Instance& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "location: " << i.location (); if (i.id ()) { @@ -49717,6 +53047,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Location& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "x: " << i.x (); o << ::std::endl << "y: " << i.y (); o << ::std::endl << "z: " << i.z (); @@ -49735,6 +53067,13 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const SynapticConnection& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + + if (i.neuroLexId ()) + { + o << ::std::endl << "neuroLexId: " << *i.neuroLexId (); + } + o << ::std::endl << "from: " << i.from (); o << ::std::endl << "to: " << i.to (); o << ::std::endl << "synapse: " << i.synapse (); @@ -49784,6 +53123,11 @@ namespace neuroml2 { o << static_cast< const ::neuroml2::BaseNonNegativeIntegerId& > (i); + if (i.neuroLexId ()) + { + o << ::std::endl << "neuroLexId: " << *i.neuroLexId (); + } + return o; } @@ -49947,6 +53291,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const ExplicitInput& i) { + o << static_cast< const ::neuroml2::BaseWithoutId& > (i); + o << ::std::endl << "target: " << i.target (); o << ::std::endl << "input: " << i.input (); if (i.destination ()) @@ -49984,7 +53330,8 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream& o, const Input& i) { - o << ::std::endl << "id: " << i.id (); + o << static_cast< const ::neuroml2::BaseNonNegativeIntegerId& > (i); + o << ::std::endl << "target: " << i.target (); o << ::std::endl << "destination: " << i.destination (); if (i.segmentId ()) @@ -50867,6 +54214,25 @@ namespace neuroml2 l << static_cast< const ::xml_schema::string& > (i); } + void + operator<< (::xercesc::DOMElement& e, const Nml2PopulationReferencePath& i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const Nml2PopulationReferencePath& i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const Nml2PopulationReferencePath& i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + void operator<< (::xercesc::DOMElement& e, const NonNegativeInteger& i) { @@ -50963,9 +54329,26 @@ namespace neuroml2 } void - operator<< (::xercesc::DOMElement& e, const Property& i) + operator<< (::xercesc::DOMElement& e, const BaseWithoutId& i) { e << static_cast< const ::xml_schema::type& > (i); + } + + void + operator<< (::xercesc::DOMAttr&, const BaseWithoutId&) + { + } + + void + operator<< (::xml_schema::list_stream&, + const BaseWithoutId&) + { + } + + void + operator<< (::xercesc::DOMElement& e, const Property& i) + { + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // tag // @@ -50993,7 +54376,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Annotation& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); } void @@ -51031,6 +54414,21 @@ namespace neuroml2 s << *b; } + // DerivedParameter + // + for (ComponentType::DerivedParameter_const_iterator + b (i.DerivedParameter ().begin ()), n (i.DerivedParameter ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "DerivedParameter", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + // Constant // for (ComponentType::Constant_const_iterator @@ -51145,7 +54543,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Constant& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // name // @@ -51196,7 +54594,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Exposure& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // name // @@ -51236,7 +54634,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const NamedDimensionalType& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // name // @@ -51276,7 +54674,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const NamedDimensionalVariable& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // name // @@ -51331,6 +54729,23 @@ namespace neuroml2 e << static_cast< const ::neuroml2::NamedDimensionalType& > (i); } + void + operator<< (::xercesc::DOMElement& e, const DerivedParameter& i) + { + e << static_cast< const ::neuroml2::NamedDimensionalType& > (i); + + // value + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "value", + e)); + + a << i.value (); + } + } + void operator<< (::xercesc::DOMElement& e, const LEMS_Property& i) { @@ -51447,6 +54862,64 @@ namespace neuroml2 s << *b; } + + // OnStart + // + if (i.OnStart ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "OnStart", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *i.OnStart (); + } + + // OnEvent + // + for (Dynamics::OnEvent_const_iterator + b (i.OnEvent ().begin ()), n (i.OnEvent ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "OnEvent", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + + // OnCondition + // + for (Dynamics::OnCondition_const_iterator + b (i.OnCondition ().begin ()), n (i.OnCondition ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "OnCondition", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + + // Regime + // + for (Dynamics::Regime_const_iterator + b (i.Regime ().begin ()), n (i.Regime ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "Regime", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } } void @@ -51563,6 +55036,308 @@ namespace neuroml2 } } + void + operator<< (::xercesc::DOMElement& e, const OnStart& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // StateAssignment + // + for (OnStart::StateAssignment_const_iterator + b (i.StateAssignment ().begin ()), n (i.StateAssignment ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "StateAssignment", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + } + + void + operator<< (::xercesc::DOMElement& e, const StateAssignment& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // variable + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "variable", + e)); + + a << i.variable (); + } + + // value + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "value", + e)); + + a << i.value (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const OnEvent& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // StateAssignment + // + for (OnEvent::StateAssignment_const_iterator + b (i.StateAssignment ().begin ()), n (i.StateAssignment ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "StateAssignment", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + + // EventOut + // + for (OnEvent::EventOut_const_iterator + b (i.EventOut ().begin ()), n (i.EventOut ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "EventOut", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + + // port + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "port", + e)); + + a << i.port (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const EventOut& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // port + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "port", + e)); + + a << i.port (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const OnCondition& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // StateAssignment + // + for (OnCondition::StateAssignment_const_iterator + b (i.StateAssignment ().begin ()), n (i.StateAssignment ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "StateAssignment", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + + // EventOut + // + for (OnCondition::EventOut_const_iterator + b (i.EventOut ().begin ()), n (i.EventOut ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "EventOut", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + + // Transition + // + if (i.Transition ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "Transition", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *i.Transition (); + } + + // test + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "test", + e)); + + a << i.test (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const Transition& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // regime + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "regime", + e)); + + a << i.regime (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const Regime& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // TimeDerivative + // + for (Regime::TimeDerivative_const_iterator + b (i.TimeDerivative ().begin ()), n (i.TimeDerivative ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "TimeDerivative", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + + // OnEntry + // + if (i.OnEntry ()) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "OnEntry", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *i.OnEntry (); + } + + // OnCondition + // + for (Regime::OnCondition_const_iterator + b (i.OnCondition ().begin ()), n (i.OnCondition ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "OnCondition", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + + // name + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "name", + e)); + + a << i.name (); + } + + // initial + // + if (i.initial ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "initial", + e)); + + a << *i.initial (); + } + } + + void + operator<< (::xercesc::DOMElement& e, const OnEntry& i) + { + e << static_cast< const ::xml_schema::type& > (i); + + // StateAssignment + // + for (OnEntry::StateAssignment_const_iterator + b (i.StateAssignment ().begin ()), n (i.StateAssignment ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "StateAssignment", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + } + + void + operator<< (::xercesc::DOMElement& e, const TrueOrFalse& i) + { + e << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xercesc::DOMAttr& a, const TrueOrFalse& i) + { + a << static_cast< const ::xml_schema::string& > (i); + } + + void + operator<< (::xml_schema::list_stream& l, + const TrueOrFalse& i) + { + l << static_cast< const ::xml_schema::string& > (i); + } + void operator<< (::xercesc::DOMElement& e, const ZeroToOne& i) { @@ -51730,24 +55505,6 @@ namespace neuroml2 return d; } - void - operator<< (::xercesc::DOMElement& e, const BaseWithoutId& i) - { - e << static_cast< const ::xml_schema::type& > (i); - - // neuroLexId - // - if (i.neuroLexId ()) - { - ::xercesc::DOMAttr& a ( - ::xsd::cxx::xml::dom::create_attribute ( - "neuroLexId", - e)); - - a << *i.neuroLexId (); - } - } - void operator<< (::xercesc::DOMElement& e, const Base& i) { @@ -52354,6 +56111,21 @@ namespace neuroml2 s << *b; } + // hindmarshRose1984Cell + // + for (NeuroMLDocument_base::hindmarshRose1984Cell_const_iterator + b (i.hindmarshRose1984Cell ().begin ()), n (i.hindmarshRose1984Cell ().end ()); + b != n; ++b) + { + ::xercesc::DOMElement& s ( + ::xsd::cxx::xml::dom::create_element ( + "hindmarshRose1984Cell", + "http://www.neuroml.org/schema/neuroml2", + e)); + + s << *b; + } + // pulseGenerator // for (NeuroMLDocument_base::pulseGenerator_const_iterator @@ -52871,6 +56643,18 @@ namespace neuroml2 s << *b; } + + // neuroLexId + // + if (i.neuroLexId ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "neuroLexId", + e)); + + a << *i.neuroLexId (); + } } void @@ -52916,6 +56700,18 @@ namespace neuroml2 a << *i.conductance (); } + + // neuroLexId + // + if (i.neuroLexId ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "neuroLexId", + e)); + + a << *i.neuroLexId (); + } } void @@ -53125,7 +56921,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Q10ConductanceScaling& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // q10Factor // @@ -54134,7 +57930,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const HHRate& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // type // @@ -54187,7 +57983,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const HHVariable& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // type // @@ -54240,7 +58036,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const HHTime& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // type // @@ -54406,6 +58202,18 @@ namespace neuroml2 operator<< (::xercesc::DOMElement& e, const BaseSynapse& i) { e << static_cast< const ::neuroml2::Standalone& > (i); + + // neuroLexId + // + if (i.neuroLexId ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "neuroLexId", + e)); + + a << *i.neuroLexId (); + } } void @@ -54821,7 +58629,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const BlockMechanism& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // type // @@ -54901,7 +58709,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const PlasticityMechanism& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // type // @@ -54953,6 +58761,18 @@ namespace neuroml2 operator<< (::xercesc::DOMElement& e, const BaseCell& i) { e << static_cast< const ::neuroml2::Standalone& > (i); + + // neuroLexId + // + if (i.neuroLexId ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "neuroLexId", + e)); + + a << *i.neuroLexId (); + } } void @@ -55736,6 +59556,133 @@ namespace neuroml2 } } + void + operator<< (::xercesc::DOMElement& e, const HindmarshRose1984Cell& i) + { + e << static_cast< const ::neuroml2::BaseCellMembPotCap& > (i); + + // a + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "a", + e)); + + a << i.a (); + } + + // b + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "b", + e)); + + a << i.b (); + } + + // c + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "c", + e)); + + a << i.c (); + } + + // d + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "d", + e)); + + a << i.d (); + } + + // s + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "s", + e)); + + a << i.s (); + } + + // x1 + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "x1", + e)); + + a << i.x1 (); + } + + // r + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "r", + e)); + + a << i.r (); + } + + // x0 + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "x0", + e)); + + a << i.x0 (); + } + + // y0 + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "y0", + e)); + + a << i.y0 (); + } + + // z0 + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "z0", + e)); + + a << i.z0 (); + } + + // v_scaling + // + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "v_scaling", + e)); + + a << i.v_scaling (); + } + } + void operator<< (::xercesc::DOMElement& e, const Cell& i) { @@ -55918,12 +59865,24 @@ namespace neuroml2 a << *i.name (); } + + // neuroLexId + // + if (i.neuroLexId ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "neuroLexId", + e)); + + a << *i.neuroLexId (); + } } void operator<< (::xercesc::DOMElement& e, const SegmentParent& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // segment // @@ -55951,7 +59910,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Point3DWithDiam& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // x // @@ -56118,6 +60077,18 @@ namespace neuroml2 s << *b; } + + // neuroLexId + // + if (i.neuroLexId ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "neuroLexId", + e)); + + a << *i.neuroLexId (); + } } void @@ -56196,7 +60167,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const ProximalDetails& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // translationStart // @@ -56213,7 +60184,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const DistalDetails& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // normalizationEnd // @@ -56230,7 +60201,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Member& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // segment // @@ -56247,7 +60218,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Include& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // segmentGroup // @@ -56264,7 +60235,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Path& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // from // @@ -56296,7 +60267,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const SubTree& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // from // @@ -56328,7 +60299,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const SegmentEndPoint& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // segment // @@ -56433,7 +60404,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const MembraneProperties& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // channelPopulation // @@ -56640,7 +60611,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const SpikeThresh& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // value // @@ -56668,7 +60639,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const SpecificCapacitance& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // value // @@ -56696,7 +60667,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const InitMembPotential& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // value // @@ -56724,7 +60695,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Resistivity& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // value // @@ -57336,7 +61307,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const InhomogeneousValue& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // inhomogeneousParameter // @@ -57364,18 +61335,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Species& i) { - e << static_cast< const ::xml_schema::type& > (i); - - // id - // - { - ::xercesc::DOMAttr& a ( - ::xsd::cxx::xml::dom::create_attribute ( - "id", - e)); - - a << i.id (); - } + e << static_cast< const ::neuroml2::Base& > (i); // concentrationModel // @@ -57454,7 +61414,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const IntracellularProperties& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // species // @@ -57517,7 +61477,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const ExtracellularPropertiesLocal& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::Base& > (i); // species // @@ -58573,6 +62533,18 @@ namespace neuroml2 a << *i.temperature (); } + + // neuroLexId + // + if (i.neuroLexId ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "neuroLexId", + e)); + + a << *i.neuroLexId (); + } } void @@ -58628,7 +62600,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const SpaceStructure& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // xSpacing // @@ -58816,6 +62788,18 @@ namespace neuroml2 a << *i.extracellularProperties (); } + + // neuroLexId + // + if (i.neuroLexId ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "neuroLexId", + e)); + + a << *i.neuroLexId (); + } } void @@ -58840,7 +62824,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Layout& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // random // @@ -58897,7 +62881,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const UnstructuredLayout& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // number // @@ -58915,7 +62899,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const RandomLayout& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // number // @@ -58945,7 +62929,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const GridLayout& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // xSize // @@ -58987,7 +62971,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Instance& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // location // @@ -59053,7 +63037,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Location& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // x // @@ -59109,7 +63093,19 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const SynapticConnection& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); + + // neuroLexId + // + if (i.neuroLexId ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "neuroLexId", + e)); + + a << *i.neuroLexId (); + } // from // @@ -59236,6 +63232,18 @@ namespace neuroml2 operator<< (::xercesc::DOMElement& e, const BaseConnection& i) { e << static_cast< const ::neuroml2::BaseNonNegativeIntegerId& > (i); + + // neuroLexId + // + if (i.neuroLexId ()) + { + ::xercesc::DOMAttr& a ( + ::xsd::cxx::xml::dom::create_attribute ( + "neuroLexId", + e)); + + a << *i.neuroLexId (); + } } void @@ -59612,7 +63620,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const ExplicitInput& i) { - e << static_cast< const ::xml_schema::type& > (i); + e << static_cast< const ::neuroml2::BaseWithoutId& > (i); // target // @@ -59710,18 +63718,7 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement& e, const Input& i) { - e << static_cast< const ::xml_schema::type& > (i); - - // id - // - { - ::xercesc::DOMAttr& a ( - ::xsd::cxx::xml::dom::create_attribute ( - "id", - e)); - - a << i.id (); - } + e << static_cast< const ::neuroml2::BaseNonNegativeIntegerId& > (i); // target // diff --git a/src/schema/NeuroML_v2.2.hxx b/src/schema/NeuroML_v2.3.hxx similarity index 93% rename from src/schema/NeuroML_v2.2.hxx rename to src/schema/NeuroML_v2.3.hxx index a8f19f2..aa1f763 100644 --- a/src/schema/NeuroML_v2.2.hxx +++ b/src/schema/NeuroML_v2.3.hxx @@ -33,11 +33,11 @@ /** * @file - * @brief Generated from NeuroML_v2.2.xsd. + * @brief Generated from NeuroML_v2.3.xsd. */ -#ifndef NEUROML_API_SCHEMA_NEURO_ML_V2_2_HXX -#define NEUROML_API_SCHEMA_NEURO_ML_V2_2_HXX +#ifndef NEUROML_API_SCHEMA_NEURO_ML_V2_3_HXX +#define NEUROML_API_SCHEMA_NEURO_ML_V2_3_HXX #ifndef XSD_CXX11 #define XSD_CXX11 @@ -641,11 +641,13 @@ namespace neuroml2 class Nml2Quantity_conductancePerVoltage; class MetaId; class NeuroLexId; + class Nml2PopulationReferencePath; class NonNegativeInteger; class PositiveInteger; class DoubleGreaterThanZero; class ZeroOrOne; class Notes; + class BaseWithoutId; class Property; class Annotation; class ComponentType; @@ -654,6 +656,7 @@ namespace neuroml2 class NamedDimensionalType; class NamedDimensionalVariable; class Parameter; + class DerivedParameter; class LEMS_Property; class Requirement; class InstanceRequirement; @@ -663,8 +666,16 @@ namespace neuroml2 class ConditionalDerivedVariable; class Case; class TimeDerivative; + class OnStart; + class StateAssignment; + class OnEvent; + class EventOut; + class OnCondition; + class Transition; + class Regime; + class OnEntry; + class TrueOrFalse; class ZeroToOne; - class BaseWithoutId; class Base; class Standalone; class NeuroMLDocument_base; @@ -731,6 +742,7 @@ namespace neuroml2 class FitzHughNagumoCell; class FitzHughNagumo1969Cell; class PinskyRinzelCA3Cell; + class HindmarshRose1984Cell; class Cell; class Cell2CaPools; class Morphology_base; @@ -3348,6 +3360,120 @@ namespace neuroml2 ~NeuroLexId (); }; + /** + * @brief Class corresponding to the %Nml2PopulationReferencePath schema type. + * + * A path referring to another component. + * + * @nosubgrouping + */ + class Nml2PopulationReferencePath: public ::xml_schema::string + { + public: + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from initializers for required + * elements and attributes. + */ + Nml2PopulationReferencePath (); + + /** + * @brief Create an instance from a C string and initializers + * for required elements and attributes. + */ + Nml2PopulationReferencePath (const char*); + + /** + * @brief Create an instance from a string andinitializers + * for required elements and attributes. + */ + Nml2PopulationReferencePath (const ::std::string&); + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + Nml2PopulationReferencePath (const ::xml_schema::string&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + Nml2PopulationReferencePath (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a DOM attribute. + * + * @param a A DOM attribute to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + Nml2PopulationReferencePath (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a string fragment. + * + * @param s A string fragment to extract the data from. + * @param e A pointer to DOM element containing the string fragment. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + Nml2PopulationReferencePath (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + Nml2PopulationReferencePath (const Nml2PopulationReferencePath& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual Nml2PopulationReferencePath* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + //@} + + /** + * @brief Destructor. + */ + virtual + ~Nml2PopulationReferencePath (); + }; + /** * @brief Class corresponding to the %NonNegativeInteger schema type. * @@ -3837,6 +3963,110 @@ namespace neuroml2 ~Notes (); }; + /** + * @brief Class corresponding to the %BaseWithoutId schema type. + * + * Base element without ID specified *yet*, e.g. for an element with a + * particular requirement on its id which does not comply with NmlId + * (e.g. Segment needs nonNegativeInteger). + * + * @nosubgrouping + */ + { + public: + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + BaseWithoutId (); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + BaseWithoutId (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a DOM attribute. + * + * @param a A DOM attribute to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + BaseWithoutId (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a string fragment. + * + * @param s A string fragment to extract the data from. + * @param e A pointer to DOM element containing the string fragment. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + BaseWithoutId (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + BaseWithoutId (const BaseWithoutId& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual BaseWithoutId* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + //@} + + /** + * @brief Destructor. + */ + virtual + ~BaseWithoutId (); + }; + + bool + operator== (const BaseWithoutId&, const BaseWithoutId&); + + bool + operator!= (const BaseWithoutId&, const BaseWithoutId&); + + /** * @brief Class corresponding to the %Property schema type. * @@ -3855,6 +4085,7 @@ namespace neuroml2 * * @nosubgrouping */ + class Property: public ::neuroml2::BaseWithoutId { public: /** @@ -4076,6 +4307,7 @@ namespace neuroml2 * * @nosubgrouping */ + class Annotation: public ::neuroml2::BaseWithoutId { public: /** @@ -4152,13 +4384,6 @@ namespace neuroml2 //@endcond }; - bool - operator== (const Annotation&, const Annotation&); - - bool - operator!= (const Annotation&, const Annotation&); - - /** * @brief Class corresponding to the %ComponentType schema type. * @@ -4296,6 +4521,70 @@ namespace neuroml2 //@} + /** + * @name DerivedParameter + * + * @brief Accessor and modifier functions for the %DerivedParameter + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::DerivedParameter DerivedParameter_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< DerivedParameter_type > DerivedParameter_sequence; + + /** + * @brief Element iterator type. + */ + typedef DerivedParameter_sequence::iterator DerivedParameter_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef DerivedParameter_sequence::const_iterator DerivedParameter_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< DerivedParameter_type, char > DerivedParameter_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const DerivedParameter_sequence& + DerivedParameter () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + DerivedParameter_sequence& + DerivedParameter (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + DerivedParameter (const DerivedParameter_sequence& s); + + //@} + /** * @name Constant * @@ -4909,6 +5198,7 @@ namespace neuroml2 protected: Property_sequence Property_; Parameter_sequence Parameter_; + DerivedParameter_sequence DerivedParameter_; Constant_sequence Constant_; Exposure_sequence Exposure_; Requirement_sequence Requirement_; @@ -4935,6 +5225,7 @@ namespace neuroml2 * * @nosubgrouping */ + class Constant: public ::neuroml2::BaseWithoutId { public: /** @@ -5292,6 +5583,7 @@ namespace neuroml2 * * @nosubgrouping */ + class Exposure: public ::neuroml2::BaseWithoutId { public: /** @@ -5587,6 +5879,7 @@ namespace neuroml2 * * @nosubgrouping */ + class NamedDimensionalType: public ::neuroml2::BaseWithoutId { public: /** @@ -5882,6 +6175,7 @@ namespace neuroml2 * * @nosubgrouping */ + class NamedDimensionalVariable: public ::neuroml2::BaseWithoutId { public: /** @@ -6318,6 +6612,169 @@ namespace neuroml2 ~Parameter (); }; + /** + * @brief Class corresponding to the %DerivedParameter schema type. + * + * LEMS DerivedParamter element + * + * @nosubgrouping + */ + class DerivedParameter: public ::neuroml2::NamedDimensionalType + { + public: + /** + * @name value + * + * @brief Accessor and modifier functions for the %value + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::xml_schema::string value_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< value_type, char > value_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const value_type& + value () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + value_type& + value (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + value (const value_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + value (::std::unique_ptr< value_type > p); + + //@} + + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + DerivedParameter (const name_type&, + const dimension_type&, + const value_type&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + DerivedParameter (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + DerivedParameter (const DerivedParameter& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual DerivedParameter* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + /** + * @brief Copy assignment operator. + * + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. + */ + DerivedParameter& + operator= (const DerivedParameter& x); + + //@} + + /** + * @brief Destructor. + */ + virtual + ~DerivedParameter (); + + // Implementation. + // + + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< value_type > value_; + + //@endcond + }; + + bool + operator== (const DerivedParameter&, const DerivedParameter&); + + bool + operator!= (const DerivedParameter&, const DerivedParameter&); + + /** * @brief Class corresponding to the %LEMS_Property schema type. * @@ -7037,6 +7494,274 @@ namespace neuroml2 //@} + /** + * @name OnStart + * + * @brief Accessor and modifier functions for the %OnStart + * optional element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::OnStart OnStart_type; + + /** + * @brief Element optional container type. + */ + typedef ::xsd::cxx::tree::optional< OnStart_type > OnStart_optional; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< OnStart_type, char > OnStart_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * container. + * + * @return A constant reference to the optional container. + */ + const OnStart_optional& + OnStart () const; + + /** + * @brief Return a read-write reference to the element container. + * + * @return A reference to the optional container. + */ + OnStart_optional& + OnStart (); + + /** + * @brief Set the element value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. + */ + void + OnStart (const OnStart_type& x); + + /** + * @brief Set the element value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. + */ + void + OnStart (const OnStart_optional& x); + + /** + * @brief Set the element value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + OnStart (::std::unique_ptr< OnStart_type > p); + + //@} + + /** + * @name OnEvent + * + * @brief Accessor and modifier functions for the %OnEvent + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::OnEvent OnEvent_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< OnEvent_type > OnEvent_sequence; + + /** + * @brief Element iterator type. + */ + typedef OnEvent_sequence::iterator OnEvent_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef OnEvent_sequence::const_iterator OnEvent_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< OnEvent_type, char > OnEvent_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const OnEvent_sequence& + OnEvent () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + OnEvent_sequence& + OnEvent (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + OnEvent (const OnEvent_sequence& s); + + //@} + + /** + * @name OnCondition + * + * @brief Accessor and modifier functions for the %OnCondition + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::OnCondition OnCondition_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< OnCondition_type > OnCondition_sequence; + + /** + * @brief Element iterator type. + */ + typedef OnCondition_sequence::iterator OnCondition_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef OnCondition_sequence::const_iterator OnCondition_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< OnCondition_type, char > OnCondition_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const OnCondition_sequence& + OnCondition () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + OnCondition_sequence& + OnCondition (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + OnCondition (const OnCondition_sequence& s); + + //@} + + /** + * @name Regime + * + * @brief Accessor and modifier functions for the %Regime + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::Regime Regime_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< Regime_type > Regime_sequence; + + /** + * @brief Element iterator type. + */ + typedef Regime_sequence::iterator Regime_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef Regime_sequence::const_iterator Regime_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< Regime_type, char > Regime_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const Regime_sequence& + Regime () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + Regime_sequence& + Regime (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + Regime (const Regime_sequence& s); + + //@} + /** * @name Constructors */ @@ -7122,6 +7847,10 @@ namespace neuroml2 DerivedVariable_sequence DerivedVariable_; ConditionalDerivedVariable_sequence ConditionalDerivedVariable_; TimeDerivative_sequence TimeDerivative_; + OnStart_optional OnStart_; + OnEvent_sequence OnEvent_; + OnCondition_sequence OnCondition_; + Regime_sequence Regime_; //@endcond }; @@ -8079,185 +8808,73 @@ namespace neuroml2 /** - * @brief Class corresponding to the %ZeroToOne schema type. - * - * Float value restricted to between 1 and 0 - * - * @nosubgrouping - */ - class ZeroToOne: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::float_, char, ::xml_schema::simple_type > - { - public: - /** - * @name Constructors - */ - //@{ - - /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. - */ - ZeroToOne (const ::xml_schema::float_&); - - /** - * @brief Create an instance from a DOM element. - * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. - */ - ZeroToOne (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Create an instance from a DOM attribute. - * - * @param a A DOM attribute to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. - */ - ZeroToOne (const ::xercesc::DOMAttr& a, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Create an instance from a string fragment. - * - * @param s A string fragment to extract the data from. - * @param e A pointer to DOM element containing the string fragment. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. - */ - ZeroToOne (const ::std::string& s, - const ::xercesc::DOMElement* e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Copy constructor. - * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * - * For polymorphic object models use the @c _clone function instead. - */ - ZeroToOne (const ZeroToOne& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Copy the instance polymorphically. - * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. - * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. - */ - virtual ZeroToOne* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; - - //@} - - /** - * @brief Destructor. - */ - virtual - ~ZeroToOne (); - }; - - /** - * @brief Class corresponding to the %BaseWithoutId schema type. - * - * Base element without ID specified *yet*, e.g. for an element with a - * particular requirement on its id which does not comply with NmlId - * (e.g. Segment needs nonNegativeInteger). + * @brief Class corresponding to the %OnStart schema type. * * @nosubgrouping */ { public: /** - * @name neuroLexId + * @name StateAssignment * - * @brief Accessor and modifier functions for the %neuroLexId - * optional attribute. + * @brief Accessor and modifier functions for the %StateAssignment + * sequence element. */ //@{ /** - * @brief Attribute type. + * @brief Element type. */ - typedef ::neuroml2::NeuroLexId neuroLexId_type; + typedef ::neuroml2::StateAssignment StateAssignment_type; /** - * @brief Attribute optional container type. + * @brief Element sequence container type. */ - typedef ::xsd::cxx::tree::optional< neuroLexId_type > neuroLexId_optional; + typedef ::xsd::cxx::tree::sequence< StateAssignment_type > StateAssignment_sequence; /** - * @brief Attribute traits type. + * @brief Element iterator type. */ - typedef ::xsd::cxx::tree::traits< neuroLexId_type, char > neuroLexId_traits; + typedef StateAssignment_sequence::iterator StateAssignment_iterator; /** - * @brief Return a read-only (constant) reference to the attribute - * container. - * - * @return A constant reference to the optional container. + * @brief Element constant iterator type. */ - const neuroLexId_optional& - neuroLexId () const; + typedef StateAssignment_sequence::const_iterator StateAssignment_const_iterator; /** - * @brief Return a read-write reference to the attribute container. - * - * @return A reference to the optional container. + * @brief Element traits type. */ - neuroLexId_optional& - neuroLexId (); + typedef ::xsd::cxx::tree::traits< StateAssignment_type, char > StateAssignment_traits; /** - * @brief Set the attribute value. - * - * @param x A new value to set. + * @brief Return a read-only (constant) reference to the element + * sequence. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * @return A constant reference to the sequence container. */ - void - neuroLexId (const neuroLexId_type& x); + const StateAssignment_sequence& + StateAssignment () const; /** - * @brief Set the attribute value. - * - * @param x An optional container with the new value to set. + * @brief Return a read-write reference to the element sequence. * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. + * @return A reference to the sequence container. */ - void - neuroLexId (const neuroLexId_optional& x); + StateAssignment_sequence& + StateAssignment (); /** - * @brief Set the attribute value without copying. + * @brief Copy elements from a given sequence. * - * @param p A new value to use. + * @param s A sequence to copy elements from. * - * This function will try to use the passed value directly instead - * of making a copy. + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. */ void - neuroLexId (::std::unique_ptr< neuroLexId_type > p); + StateAssignment (const StateAssignment_sequence& s); //@} @@ -8270,7 +8887,7 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - BaseWithoutId (); + OnStart (); /** * @brief Create an instance from a DOM element. @@ -8280,9 +8897,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - BaseWithoutId (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + OnStart (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -8293,9 +8910,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BaseWithoutId (const BaseWithoutId& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + OnStart (const OnStart& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -8308,7 +8925,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual BaseWithoutId* + virtual OnStart* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -8320,8 +8937,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BaseWithoutId& - operator= (const BaseWithoutId& x); + OnStart& + operator= (const OnStart& x); //@} @@ -8329,7 +8946,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~BaseWithoutId (); + ~OnStart (); // Implementation. // @@ -8342,33 +8959,29 @@ namespace neuroml2 ::xml_schema::flags); protected: - neuroLexId_optional neuroLexId_; + StateAssignment_sequence StateAssignment_; //@endcond }; bool - operator== (const BaseWithoutId&, const BaseWithoutId&); + operator== (const OnStart&, const OnStart&); bool - operator!= (const BaseWithoutId&, const BaseWithoutId&); + operator!= (const OnStart&, const OnStart&); /** - * @brief Class corresponding to the %Base schema type. - * - * Anything which can have a unique (within its parent) id of the form - * NmlId (spaceless combination of letters, numbers and underscore). + * @brief Class corresponding to the %StateAssignment schema type. * * @nosubgrouping */ - class Base: public ::neuroml2::BaseWithoutId { public: /** - * @name id + * @name variable * - * @brief Accessor and modifier functions for the %id + * @brief Accessor and modifier functions for the %variable * required attribute. */ //@{ @@ -8376,28 +8989,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::NmlId id_type; + typedef ::xml_schema::string variable_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< id_type, char > id_traits; + typedef ::xsd::cxx::tree::traits< variable_type, char > variable_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const id_type& - id () const; + const variable_type& + variable () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - id_type& - id (); + variable_type& + variable (); /** * @brief Set the attribute value. @@ -8408,7 +9021,7 @@ namespace neuroml2 * the new value of the attribute. */ void - id (const id_type& x); + variable (const variable_type& x); /** * @brief Set the attribute value without copying. @@ -8419,7 +9032,65 @@ namespace neuroml2 * instead of making a copy. */ void - id (::std::unique_ptr< id_type > p); + variable (::std::unique_ptr< variable_type > p); + + //@} + + /** + * @name value + * + * @brief Accessor and modifier functions for the %value + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::xml_schema::string value_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< value_type, char > value_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const value_type& + value () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + value_type& + value (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + value (const value_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + value (::std::unique_ptr< value_type > p); //@} @@ -8432,7 +9103,8 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - Base (const id_type&); + StateAssignment (const variable_type&, + const value_type&); /** * @brief Create an instance from a DOM element. @@ -8442,9 +9114,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - Base (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + StateAssignment (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -8455,9 +9127,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - Base (const Base& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + StateAssignment (const StateAssignment& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -8470,7 +9142,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual Base* + virtual StateAssignment* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -8482,8 +9154,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - Base& - operator= (const Base& x); + StateAssignment& + operator= (const StateAssignment& x); //@} @@ -8491,7 +9163,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~Base (); + ~StateAssignment (); // Implementation. // @@ -8504,109 +9176,30 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< id_type > id_; + ::xsd::cxx::tree::one< variable_type > variable_; + ::xsd::cxx::tree::one< value_type > value_; //@endcond }; bool - operator== (const Base&, const Base&); + operator== (const StateAssignment&, const StateAssignment&); bool - operator!= (const Base&, const Base&); + operator!= (const StateAssignment&, const StateAssignment&); /** - * @brief Class corresponding to the %Standalone schema type. - * - * Elements which can stand alone and be referenced by id, e.g. cell, - * morphology. + * @brief Class corresponding to the %OnEvent schema type. * * @nosubgrouping */ - class Standalone: public ::neuroml2::Base { public: /** - * @name notes - * - * @brief Accessor and modifier functions for the %notes - * optional element. - */ - //@{ - - /** - * @brief Element type. - */ - typedef ::neuroml2::Notes notes_type; - - /** - * @brief Element optional container type. - */ - typedef ::xsd::cxx::tree::optional< notes_type > notes_optional; - - /** - * @brief Element traits type. - */ - typedef ::xsd::cxx::tree::traits< notes_type, char > notes_traits; - - /** - * @brief Return a read-only (constant) reference to the element - * container. - * - * @return A constant reference to the optional container. - */ - const notes_optional& - notes () const; - - /** - * @brief Return a read-write reference to the element container. - * - * @return A reference to the optional container. - */ - notes_optional& - notes (); - - /** - * @brief Set the element value. - * - * @param x A new value to set. - * - * This function makes a copy of its argument and sets it as - * the new value of the element. - */ - void - notes (const notes_type& x); - - /** - * @brief Set the element value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. - */ - void - notes (const notes_optional& x); - - /** - * @brief Set the element value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly instead - * of making a copy. - */ - void - notes (::std::unique_ptr< notes_type > p); - - //@} - - /** - * @name property + * @name StateAssignment * - * @brief Accessor and modifier functions for the %property + * @brief Accessor and modifier functions for the %StateAssignment * sequence element. */ //@{ @@ -8614,27 +9207,27 @@ namespace neuroml2 /** * @brief Element type. */ - typedef ::neuroml2::Property property_type; + typedef ::neuroml2::StateAssignment StateAssignment_type; /** * @brief Element sequence container type. */ - typedef ::xsd::cxx::tree::sequence< property_type > property_sequence; + typedef ::xsd::cxx::tree::sequence< StateAssignment_type > StateAssignment_sequence; /** * @brief Element iterator type. */ - typedef property_sequence::iterator property_iterator; + typedef StateAssignment_sequence::iterator StateAssignment_iterator; /** * @brief Element constant iterator type. */ - typedef property_sequence::const_iterator property_const_iterator; + typedef StateAssignment_sequence::const_iterator StateAssignment_const_iterator; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< property_type, char > property_traits; + typedef ::xsd::cxx::tree::traits< StateAssignment_type, char > StateAssignment_traits; /** * @brief Return a read-only (constant) reference to the element @@ -8642,16 +9235,16 @@ namespace neuroml2 * * @return A constant reference to the sequence container. */ - const property_sequence& - property () const; + const StateAssignment_sequence& + StateAssignment () const; /** * @brief Return a read-write reference to the element sequence. * * @return A reference to the sequence container. */ - property_sequence& - property (); + StateAssignment_sequence& + StateAssignment (); /** * @brief Copy elements from a given sequence. @@ -8663,125 +9256,107 @@ namespace neuroml2 * sequence and all old elements will be lost. */ void - property (const property_sequence& s); + StateAssignment (const StateAssignment_sequence& s); //@} /** - * @name annotation + * @name EventOut * - * @brief Accessor and modifier functions for the %annotation - * optional element. + * @brief Accessor and modifier functions for the %EventOut + * sequence element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::Annotation annotation_type; + typedef ::neuroml2::EventOut EventOut_type; /** - * @brief Element optional container type. + * @brief Element sequence container type. */ - typedef ::xsd::cxx::tree::optional< annotation_type > annotation_optional; + typedef ::xsd::cxx::tree::sequence< EventOut_type > EventOut_sequence; /** - * @brief Element traits type. + * @brief Element iterator type. */ - typedef ::xsd::cxx::tree::traits< annotation_type, char > annotation_traits; + typedef EventOut_sequence::iterator EventOut_iterator; /** - * @brief Return a read-only (constant) reference to the element - * container. - * - * @return A constant reference to the optional container. + * @brief Element constant iterator type. */ - const annotation_optional& - annotation () const; + typedef EventOut_sequence::const_iterator EventOut_const_iterator; /** - * @brief Return a read-write reference to the element container. - * - * @return A reference to the optional container. + * @brief Element traits type. */ - annotation_optional& - annotation (); + typedef ::xsd::cxx::tree::traits< EventOut_type, char > EventOut_traits; /** - * @brief Set the element value. - * - * @param x A new value to set. + * @brief Return a read-only (constant) reference to the element + * sequence. * - * This function makes a copy of its argument and sets it as - * the new value of the element. + * @return A constant reference to the sequence container. */ - void - annotation (const annotation_type& x); + const EventOut_sequence& + EventOut () const; /** - * @brief Set the element value. - * - * @param x An optional container with the new value to set. + * @brief Return a read-write reference to the element sequence. * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. + * @return A reference to the sequence container. */ - void - annotation (const annotation_optional& x); + EventOut_sequence& + EventOut (); /** - * @brief Set the element value without copying. + * @brief Copy elements from a given sequence. * - * @param p A new value to use. + * @param s A sequence to copy elements from. * - * This function will try to use the passed value directly instead - * of making a copy. + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. */ void - annotation (::std::unique_ptr< annotation_type > p); + EventOut (const EventOut_sequence& s); //@} /** - * @name metaid + * @name port * - * @brief Accessor and modifier functions for the %metaid - * optional attribute. + * @brief Accessor and modifier functions for the %port + * required attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::MetaId metaid_type; - - /** - * @brief Attribute optional container type. - */ - typedef ::xsd::cxx::tree::optional< metaid_type > metaid_optional; + typedef ::xml_schema::string port_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< metaid_type, char > metaid_traits; + typedef ::xsd::cxx::tree::traits< port_type, char > port_traits; /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const metaid_optional& - metaid () const; + const port_type& + port () const; /** - * @brief Return a read-write reference to the attribute container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - metaid_optional& - metaid (); + port_type& + port (); /** * @brief Set the attribute value. @@ -8792,30 +9367,18 @@ namespace neuroml2 * the new value of the attribute. */ void - metaid (const metaid_type& x); - - /** - * @brief Set the attribute value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. - */ - void - metaid (const metaid_optional& x); + port (const port_type& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - metaid (::std::unique_ptr< metaid_type > p); + port (::std::unique_ptr< port_type > p); //@} @@ -8828,7 +9391,7 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - Standalone (const id_type&); + OnEvent (const port_type&); /** * @brief Create an instance from a DOM element. @@ -8838,9 +9401,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - Standalone (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + OnEvent (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -8851,9 +9414,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - Standalone (const Standalone& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + OnEvent (const OnEvent& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -8866,7 +9429,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual Standalone* + virtual OnEvent* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -8878,8 +9441,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - Standalone& - operator= (const Standalone& x); + OnEvent& + operator= (const OnEvent& x); //@} @@ -8887,7 +9450,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~Standalone (); + ~OnEvent (); // Implementation. // @@ -8900,161 +9463,189 @@ namespace neuroml2 ::xml_schema::flags); protected: - notes_optional notes_; - property_sequence property_; - annotation_optional annotation_; - metaid_optional metaid_; + StateAssignment_sequence StateAssignment_; + EventOut_sequence EventOut_; + ::xsd::cxx::tree::one< port_type > port_; //@endcond }; bool - operator== (const Standalone&, const Standalone&); + operator== (const OnEvent&, const OnEvent&); bool - operator!= (const Standalone&, const Standalone&); + operator!= (const OnEvent&, const OnEvent&); /** - * @brief Class corresponding to the %NeuroMLDocument schema type. + * @brief Class corresponding to the %EventOut schema type. * * @nosubgrouping */ - class NeuroMLDocument_base: public ::neuroml2::Standalone { public: /** - * @name include + * @name port * - * @brief Accessor and modifier functions for the %include - * sequence element. + * @brief Accessor and modifier functions for the %port + * required attribute. */ //@{ /** - * @brief Element type. + * @brief Attribute type. */ - typedef ::neuroml2::IncludeType include_type; + typedef ::xml_schema::string port_type; /** - * @brief Element sequence container type. + * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::sequence< include_type > include_sequence; + typedef ::xsd::cxx::tree::traits< port_type, char > port_traits; /** - * @brief Element iterator type. + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. */ - typedef include_sequence::iterator include_iterator; + const port_type& + port () const; /** - * @brief Element constant iterator type. + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. */ - typedef include_sequence::const_iterator include_const_iterator; + port_type& + port (); /** - * @brief Element traits type. - */ - typedef ::xsd::cxx::tree::traits< include_type, char > include_traits; - - /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Set the attribute value. * - * @return A constant reference to the sequence container. - */ - const include_sequence& - include () const; - - /** - * @brief Return a read-write reference to the element sequence. + * @param x A new value to set. * - * @return A reference to the sequence container. + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - include_sequence& - include (); + void + port (const port_type& x); /** - * @brief Copy elements from a given sequence. + * @brief Set the attribute value without copying. * - * @param s A sequence to copy elements from. + * @param p A new value to use. * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * This function will try to use the passed value directly + * instead of making a copy. */ void - include (const include_sequence& s); + port (::std::unique_ptr< port_type > p); //@} /** - * @name extracellularProperties - * - * @brief Accessor and modifier functions for the %extracellularProperties - * sequence element. + * @name Constructors */ //@{ /** - * @brief Element type. - */ - typedef ::neuroml2::ExtracellularProperties extracellularProperties_type; - - /** - * @brief Element sequence container type. - */ - typedef ::xsd::cxx::tree::sequence< extracellularProperties_type > extracellularProperties_sequence; - - /** - * @brief Element iterator type. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. */ - typedef extracellularProperties_sequence::iterator extracellularProperties_iterator; + EventOut (const port_type&); /** - * @brief Element constant iterator type. + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - typedef extracellularProperties_sequence::const_iterator extracellularProperties_const_iterator; + EventOut (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Element traits type. + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. */ - typedef ::xsd::cxx::tree::traits< extracellularProperties_type, char > extracellularProperties_traits; + EventOut (const EventOut& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Copy the instance polymorphically. * - * @return A constant reference to the sequence container. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - const extracellularProperties_sequence& - extracellularProperties () const; + virtual EventOut* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; /** - * @brief Return a read-write reference to the element sequence. + * @brief Copy assignment operator. * - * @return A reference to the sequence container. + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. */ - extracellularProperties_sequence& - extracellularProperties (); + EventOut& + operator= (const EventOut& x); + + //@} /** - * @brief Copy elements from a given sequence. - * - * @param s A sequence to copy elements from. - * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * @brief Destructor. */ + virtual + ~EventOut (); + + // Implementation. + // + + //@cond + + protected: void - extracellularProperties (const extracellularProperties_sequence& s); + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); - //@} + protected: + ::xsd::cxx::tree::one< port_type > port_; + + //@endcond + }; + + bool + operator== (const EventOut&, const EventOut&); + bool + operator!= (const EventOut&, const EventOut&); + + + /** + * @brief Class corresponding to the %OnCondition schema type. + * + * @nosubgrouping + */ + { + public: /** - * @name intracellularProperties + * @name StateAssignment * - * @brief Accessor and modifier functions for the %intracellularProperties + * @brief Accessor and modifier functions for the %StateAssignment * sequence element. */ //@{ @@ -9062,27 +9653,27 @@ namespace neuroml2 /** * @brief Element type. */ - typedef ::neuroml2::IntracellularProperties intracellularProperties_type; + typedef ::neuroml2::StateAssignment StateAssignment_type; /** * @brief Element sequence container type. */ - typedef ::xsd::cxx::tree::sequence< intracellularProperties_type > intracellularProperties_sequence; + typedef ::xsd::cxx::tree::sequence< StateAssignment_type > StateAssignment_sequence; /** * @brief Element iterator type. */ - typedef intracellularProperties_sequence::iterator intracellularProperties_iterator; + typedef StateAssignment_sequence::iterator StateAssignment_iterator; /** * @brief Element constant iterator type. */ - typedef intracellularProperties_sequence::const_iterator intracellularProperties_const_iterator; + typedef StateAssignment_sequence::const_iterator StateAssignment_const_iterator; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< intracellularProperties_type, char > intracellularProperties_traits; + typedef ::xsd::cxx::tree::traits< StateAssignment_type, char > StateAssignment_traits; /** * @brief Return a read-only (constant) reference to the element @@ -9090,16 +9681,16 @@ namespace neuroml2 * * @return A constant reference to the sequence container. */ - const intracellularProperties_sequence& - intracellularProperties () const; + const StateAssignment_sequence& + StateAssignment () const; /** * @brief Return a read-write reference to the element sequence. * * @return A reference to the sequence container. */ - intracellularProperties_sequence& - intracellularProperties (); + StateAssignment_sequence& + StateAssignment (); /** * @brief Copy elements from a given sequence. @@ -9111,14 +9702,14 @@ namespace neuroml2 * sequence and all old elements will be lost. */ void - intracellularProperties (const intracellularProperties_sequence& s); + StateAssignment (const StateAssignment_sequence& s); //@} /** - * @name morphology + * @name EventOut * - * @brief Accessor and modifier functions for the %morphology + * @brief Accessor and modifier functions for the %EventOut * sequence element. */ //@{ @@ -9126,27 +9717,27 @@ namespace neuroml2 /** * @brief Element type. */ - typedef ::neuroml2::Morphology morphology_type; + typedef ::neuroml2::EventOut EventOut_type; /** * @brief Element sequence container type. */ - typedef ::xsd::cxx::tree::sequence< morphology_type > morphology_sequence; + typedef ::xsd::cxx::tree::sequence< EventOut_type > EventOut_sequence; /** * @brief Element iterator type. */ - typedef morphology_sequence::iterator morphology_iterator; + typedef EventOut_sequence::iterator EventOut_iterator; /** * @brief Element constant iterator type. */ - typedef morphology_sequence::const_iterator morphology_const_iterator; + typedef EventOut_sequence::const_iterator EventOut_const_iterator; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< morphology_type, char > morphology_traits; + typedef ::xsd::cxx::tree::traits< EventOut_type, char > EventOut_traits; /** * @brief Return a read-only (constant) reference to the element @@ -9154,16 +9745,16 @@ namespace neuroml2 * * @return A constant reference to the sequence container. */ - const morphology_sequence& - morphology () const; + const EventOut_sequence& + EventOut () const; /** * @brief Return a read-write reference to the element sequence. * * @return A reference to the sequence container. */ - morphology_sequence& - morphology (); + EventOut_sequence& + EventOut (); /** * @brief Copy elements from a given sequence. @@ -9175,270 +9766,409 @@ namespace neuroml2 * sequence and all old elements will be lost. */ void - morphology (const morphology_sequence& s); + EventOut (const EventOut_sequence& s); //@} /** - * @name ionChannel + * @name Transition * - * @brief Accessor and modifier functions for the %ionChannel - * sequence element. + * @brief Accessor and modifier functions for the %Transition + * optional element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::IonChannel ionChannel_type; + typedef ::neuroml2::Transition Transition_type; /** - * @brief Element sequence container type. + * @brief Element optional container type. */ - typedef ::xsd::cxx::tree::sequence< ionChannel_type > ionChannel_sequence; + typedef ::xsd::cxx::tree::optional< Transition_type > Transition_optional; /** - * @brief Element iterator type. + * @brief Element traits type. */ - typedef ionChannel_sequence::iterator ionChannel_iterator; + typedef ::xsd::cxx::tree::traits< Transition_type, char > Transition_traits; /** - * @brief Element constant iterator type. + * @brief Return a read-only (constant) reference to the element + * container. + * + * @return A constant reference to the optional container. */ - typedef ionChannel_sequence::const_iterator ionChannel_const_iterator; + const Transition_optional& + Transition () const; /** - * @brief Element traits type. + * @brief Return a read-write reference to the element container. + * + * @return A reference to the optional container. */ - typedef ::xsd::cxx::tree::traits< ionChannel_type, char > ionChannel_traits; + Transition_optional& + Transition (); /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Set the element value. * - * @return A constant reference to the sequence container. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. */ - const ionChannel_sequence& - ionChannel () const; + void + Transition (const Transition_type& x); /** - * @brief Return a read-write reference to the element sequence. + * @brief Set the element value. * - * @return A reference to the sequence container. + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. */ - ionChannel_sequence& - ionChannel (); + void + Transition (const Transition_optional& x); /** - * @brief Copy elements from a given sequence. + * @brief Set the element value without copying. * - * @param s A sequence to copy elements from. + * @param p A new value to use. * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * This function will try to use the passed value directly instead + * of making a copy. */ void - ionChannel (const ionChannel_sequence& s); + Transition (::std::unique_ptr< Transition_type > p); //@} /** - * @name ionChannelHH + * @name test * - * @brief Accessor and modifier functions for the %ionChannelHH - * sequence element. + * @brief Accessor and modifier functions for the %test + * required attribute. */ //@{ /** - * @brief Element type. + * @brief Attribute type. */ - typedef ::neuroml2::IonChannelHH ionChannelHH_type; + typedef ::xml_schema::string test_type; /** - * @brief Element sequence container type. + * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::sequence< ionChannelHH_type > ionChannelHH_sequence; + typedef ::xsd::cxx::tree::traits< test_type, char > test_traits; /** - * @brief Element iterator type. + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. */ - typedef ionChannelHH_sequence::iterator ionChannelHH_iterator; + const test_type& + test () const; /** - * @brief Element constant iterator type. + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. */ - typedef ionChannelHH_sequence::const_iterator ionChannelHH_const_iterator; + test_type& + test (); /** - * @brief Element traits type. + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - typedef ::xsd::cxx::tree::traits< ionChannelHH_type, char > ionChannelHH_traits; + void + test (const test_type& x); /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Set the attribute value without copying. * - * @return A constant reference to the sequence container. + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. */ - const ionChannelHH_sequence& - ionChannelHH () const; + void + test (::std::unique_ptr< test_type > p); + + //@} /** - * @brief Return a read-write reference to the element sequence. + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + OnCondition (const test_type&); + + /** + * @brief Create an instance from a DOM element. * - * @return A reference to the sequence container. + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - ionChannelHH_sequence& - ionChannelHH (); + OnCondition (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Copy elements from a given sequence. + * @brief Copy constructor. * - * @param s A sequence to copy elements from. + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * For polymorphic object models use the @c _clone function instead. */ - void - ionChannelHH (const ionChannelHH_sequence& s); - - //@} + OnCondition (const OnCondition& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @name ionChannelVShift + * @brief Copy the instance polymorphically. * - * @brief Accessor and modifier functions for the %ionChannelVShift - * sequence element. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - //@{ + virtual OnCondition* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; /** - * @brief Element type. + * @brief Copy assignment operator. + * + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. */ - typedef ::neuroml2::IonChannelVShift ionChannelVShift_type; + OnCondition& + operator= (const OnCondition& x); + + //@} /** - * @brief Element sequence container type. + * @brief Destructor. */ - typedef ::xsd::cxx::tree::sequence< ionChannelVShift_type > ionChannelVShift_sequence; + virtual + ~OnCondition (); + + // Implementation. + // + + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + StateAssignment_sequence StateAssignment_; + EventOut_sequence EventOut_; + Transition_optional Transition_; + ::xsd::cxx::tree::one< test_type > test_; + + //@endcond + }; + + bool + operator== (const OnCondition&, const OnCondition&); + + bool + operator!= (const OnCondition&, const OnCondition&); + + /** + * @brief Class corresponding to the %Transition schema type. + * + * @nosubgrouping + */ + { + public: /** - * @brief Element iterator type. + * @name regime + * + * @brief Accessor and modifier functions for the %regime + * required attribute. */ - typedef ionChannelVShift_sequence::iterator ionChannelVShift_iterator; + //@{ /** - * @brief Element constant iterator type. + * @brief Attribute type. */ - typedef ionChannelVShift_sequence::const_iterator ionChannelVShift_const_iterator; + typedef ::xml_schema::string regime_type; /** - * @brief Element traits type. + * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< ionChannelVShift_type, char > ionChannelVShift_traits; + typedef ::xsd::cxx::tree::traits< regime_type, char > regime_traits; /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the sequence container. + * @return A constant reference to the attribute. */ - const ionChannelVShift_sequence& - ionChannelVShift () const; + const regime_type& + regime () const; /** - * @brief Return a read-write reference to the element sequence. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the sequence container. + * @return A reference to the attribute. */ - ionChannelVShift_sequence& - ionChannelVShift (); + regime_type& + regime (); /** - * @brief Copy elements from a given sequence. + * @brief Set the attribute value. * - * @param s A sequence to copy elements from. + * @param x A new value to set. * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ void - ionChannelVShift (const ionChannelVShift_sequence& s); - - //@} + regime (const regime_type& x); /** - * @name ionChannelKS + * @brief Set the attribute value without copying. * - * @brief Accessor and modifier functions for the %ionChannelKS - * sequence element. + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. */ - //@{ + void + regime (::std::unique_ptr< regime_type > p); - /** - * @brief Element type. - */ - typedef ::neuroml2::IonChannelKS ionChannelKS_type; + //@} /** - * @brief Element sequence container type. + * @name Constructors */ - typedef ::xsd::cxx::tree::sequence< ionChannelKS_type > ionChannelKS_sequence; + //@{ /** - * @brief Element iterator type. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. */ - typedef ionChannelKS_sequence::iterator ionChannelKS_iterator; + Transition (const regime_type&); /** - * @brief Element constant iterator type. + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - typedef ionChannelKS_sequence::const_iterator ionChannelKS_const_iterator; + Transition (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Element traits type. + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. */ - typedef ::xsd::cxx::tree::traits< ionChannelKS_type, char > ionChannelKS_traits; + Transition (const Transition& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Copy the instance polymorphically. * - * @return A constant reference to the sequence container. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - const ionChannelKS_sequence& - ionChannelKS () const; + virtual Transition* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; /** - * @brief Return a read-write reference to the element sequence. + * @brief Copy assignment operator. * - * @return A reference to the sequence container. + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. */ - ionChannelKS_sequence& - ionChannelKS (); + Transition& + operator= (const Transition& x); + + //@} /** - * @brief Copy elements from a given sequence. - * - * @param s A sequence to copy elements from. - * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * @brief Destructor. */ + virtual + ~Transition (); + + // Implementation. + // + + //@cond + + protected: void - ionChannelKS (const ionChannelKS_sequence& s); + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); - //@} + protected: + ::xsd::cxx::tree::one< regime_type > regime_; + + //@endcond + }; + + bool + operator== (const Transition&, const Transition&); + bool + operator!= (const Transition&, const Transition&); + + + /** + * @brief Class corresponding to the %Regime schema type. + * + * @nosubgrouping + */ + { + public: /** - * @name decayingPoolConcentrationModel + * @name TimeDerivative * - * @brief Accessor and modifier functions for the %decayingPoolConcentrationModel + * @brief Accessor and modifier functions for the %TimeDerivative * sequence element. */ //@{ @@ -9446,27 +10176,27 @@ namespace neuroml2 /** * @brief Element type. */ - typedef ::neuroml2::DecayingPoolConcentrationModel decayingPoolConcentrationModel_type; + typedef ::neuroml2::TimeDerivative TimeDerivative_type; /** * @brief Element sequence container type. */ - typedef ::xsd::cxx::tree::sequence< decayingPoolConcentrationModel_type > decayingPoolConcentrationModel_sequence; + typedef ::xsd::cxx::tree::sequence< TimeDerivative_type > TimeDerivative_sequence; /** * @brief Element iterator type. */ - typedef decayingPoolConcentrationModel_sequence::iterator decayingPoolConcentrationModel_iterator; + typedef TimeDerivative_sequence::iterator TimeDerivative_iterator; /** * @brief Element constant iterator type. */ - typedef decayingPoolConcentrationModel_sequence::const_iterator decayingPoolConcentrationModel_const_iterator; + typedef TimeDerivative_sequence::const_iterator TimeDerivative_const_iterator; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< decayingPoolConcentrationModel_type, char > decayingPoolConcentrationModel_traits; + typedef ::xsd::cxx::tree::traits< TimeDerivative_type, char > TimeDerivative_traits; /** * @brief Return a read-only (constant) reference to the element @@ -9474,16 +10204,16 @@ namespace neuroml2 * * @return A constant reference to the sequence container. */ - const decayingPoolConcentrationModel_sequence& - decayingPoolConcentrationModel () const; + const TimeDerivative_sequence& + TimeDerivative () const; /** * @brief Return a read-write reference to the element sequence. * * @return A reference to the sequence container. */ - decayingPoolConcentrationModel_sequence& - decayingPoolConcentrationModel (); + TimeDerivative_sequence& + TimeDerivative (); /** * @brief Copy elements from a given sequence. @@ -9495,25 +10225,1946 @@ namespace neuroml2 * sequence and all old elements will be lost. */ void - decayingPoolConcentrationModel (const decayingPoolConcentrationModel_sequence& s); + TimeDerivative (const TimeDerivative_sequence& s); //@} /** - * @name fixedFactorConcentrationModel + * @name OnEntry * - * @brief Accessor and modifier functions for the %fixedFactorConcentrationModel - * sequence element. + * @brief Accessor and modifier functions for the %OnEntry + * optional element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::FixedFactorConcentrationModel fixedFactorConcentrationModel_type; + typedef ::neuroml2::OnEntry OnEntry_type; /** - * @brief Element sequence container type. + * @brief Element optional container type. + */ + typedef ::xsd::cxx::tree::optional< OnEntry_type > OnEntry_optional; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< OnEntry_type, char > OnEntry_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * container. + * + * @return A constant reference to the optional container. + */ + const OnEntry_optional& + OnEntry () const; + + /** + * @brief Return a read-write reference to the element container. + * + * @return A reference to the optional container. + */ + OnEntry_optional& + OnEntry (); + + /** + * @brief Set the element value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. + */ + void + OnEntry (const OnEntry_type& x); + + /** + * @brief Set the element value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. + */ + void + OnEntry (const OnEntry_optional& x); + + /** + * @brief Set the element value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + OnEntry (::std::unique_ptr< OnEntry_type > p); + + //@} + + /** + * @name OnCondition + * + * @brief Accessor and modifier functions for the %OnCondition + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::OnCondition OnCondition_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< OnCondition_type > OnCondition_sequence; + + /** + * @brief Element iterator type. + */ + typedef OnCondition_sequence::iterator OnCondition_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef OnCondition_sequence::const_iterator OnCondition_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< OnCondition_type, char > OnCondition_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const OnCondition_sequence& + OnCondition () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + OnCondition_sequence& + OnCondition (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + OnCondition (const OnCondition_sequence& s); + + //@} + + /** + * @name name + * + * @brief Accessor and modifier functions for the %name + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::xml_schema::string name_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< name_type, char > name_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const name_type& + name () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + name_type& + name (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + name (const name_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + name (::std::unique_ptr< name_type > p); + + //@} + + /** + * @name initial + * + * @brief Accessor and modifier functions for the %initial + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::TrueOrFalse initial_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< initial_type > initial_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< initial_type, char > initial_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. + */ + const initial_optional& + initial () const; + + /** + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. + */ + initial_optional& + initial (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + initial (const initial_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + initial (const initial_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + initial (::std::unique_ptr< initial_type > p); + + //@} + + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + Regime (const name_type&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + Regime (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + Regime (const Regime& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual Regime* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + /** + * @brief Copy assignment operator. + * + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. + */ + Regime& + operator= (const Regime& x); + + //@} + + /** + * @brief Destructor. + */ + virtual + ~Regime (); + + // Implementation. + // + + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + TimeDerivative_sequence TimeDerivative_; + OnEntry_optional OnEntry_; + OnCondition_sequence OnCondition_; + ::xsd::cxx::tree::one< name_type > name_; + initial_optional initial_; + + //@endcond + }; + + bool + operator== (const Regime&, const Regime&); + + bool + operator!= (const Regime&, const Regime&); + + + /** + * @brief Class corresponding to the %OnEntry schema type. + * + * @nosubgrouping + */ + { + public: + /** + * @name StateAssignment + * + * @brief Accessor and modifier functions for the %StateAssignment + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::StateAssignment StateAssignment_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< StateAssignment_type > StateAssignment_sequence; + + /** + * @brief Element iterator type. + */ + typedef StateAssignment_sequence::iterator StateAssignment_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef StateAssignment_sequence::const_iterator StateAssignment_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< StateAssignment_type, char > StateAssignment_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const StateAssignment_sequence& + StateAssignment () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + StateAssignment_sequence& + StateAssignment (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + StateAssignment (const StateAssignment_sequence& s); + + //@} + + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + OnEntry (); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + OnEntry (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + OnEntry (const OnEntry& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual OnEntry* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + /** + * @brief Copy assignment operator. + * + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. + */ + OnEntry& + operator= (const OnEntry& x); + + //@} + + /** + * @brief Destructor. + */ + virtual + ~OnEntry (); + + // Implementation. + // + + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + StateAssignment_sequence StateAssignment_; + + //@endcond + }; + + bool + operator== (const OnEntry&, const OnEntry&); + + bool + operator!= (const OnEntry&, const OnEntry&); + + + /** + * @brief Enumeration class corresponding to the %TrueOrFalse + * schema type. + */ + class TrueOrFalse: public ::xml_schema::string + { + public: + + /** + * @brief Underlying enum type. + */ + enum value + { + true_, + false_ + }; + + /** + * @brief Create an instance from the underlying enum value. + * + * @param v A enum value. + */ + TrueOrFalse (value v); + + /** + * @brief Create an instance from a C string. + * + * @param v A string value. + */ + TrueOrFalse (const char* v); + + /** + * @brief Create an instance from a string. + * + * @param v A string value. + */ + TrueOrFalse (const ::std::string& v); + + /** + * @brief Create an instance from the base value. + * + * @param v A base value. + */ + TrueOrFalse (const ::xml_schema::string& v); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + TrueOrFalse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a DOM attribute. + * + * @param a A DOM attribute to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + TrueOrFalse (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a string fragment. + * + * @param s A string fragment to extract the data from. + * @param e A pointer to DOM element containing the string fragment. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + TrueOrFalse (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + TrueOrFalse (const TrueOrFalse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual TrueOrFalse* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + /** + * @brief Assign the underlying enum value. + * + * @param v A enum value. + * @return A refernce to the instance. + */ + TrueOrFalse& + operator= (value v); + + /** + * @brief Implicit conversion operator to the underlying + * enum value. + * + * @return A enum value. + */ + virtual + operator value () const + { + return _xsd_TrueOrFalse_convert (); + } + + //@cond + + protected: + value + _xsd_TrueOrFalse_convert () const; + + public: + static const char* const _xsd_TrueOrFalse_literals_[2]; + static const value _xsd_TrueOrFalse_indexes_[2]; + + //@endcond + }; + + /** + * @brief Class corresponding to the %ZeroToOne schema type. + * + * Float value restricted to between 1 and 0 + * + * @nosubgrouping + */ + class ZeroToOne: public ::xsd::cxx::tree::fundamental_base< ::xml_schema::float_, char, ::xml_schema::simple_type > + { + public: + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + ZeroToOne (const ::xml_schema::float_&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + ZeroToOne (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a DOM attribute. + * + * @param a A DOM attribute to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + ZeroToOne (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a string fragment. + * + * @param s A string fragment to extract the data from. + * @param e A pointer to DOM element containing the string fragment. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + ZeroToOne (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + ZeroToOne (const ZeroToOne& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual ZeroToOne* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + //@} + + /** + * @brief Destructor. + */ + virtual + ~ZeroToOne (); + }; + + /** + * @brief Class corresponding to the %Base schema type. + * + * Anything which can have a unique (within its parent) id of the form + * NmlId (spaceless combination of letters, numbers and underscore). + * + * @nosubgrouping + */ + class Base: public ::neuroml2::BaseWithoutId + { + public: + /** + * @name id + * + * @brief Accessor and modifier functions for the %id + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::NmlId id_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< id_type, char > id_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const id_type& + id () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + id_type& + id (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + id (const id_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + id (::std::unique_ptr< id_type > p); + + //@} + + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + Base (const id_type&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + Base (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + Base (const Base& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual Base* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + /** + * @brief Copy assignment operator. + * + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. + */ + Base& + operator= (const Base& x); + + //@} + + /** + * @brief Destructor. + */ + virtual + ~Base (); + + // Implementation. + // + + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< id_type > id_; + + //@endcond + }; + + bool + operator== (const Base&, const Base&); + + bool + operator!= (const Base&, const Base&); + + + /** + * @brief Class corresponding to the %Standalone schema type. + * + * Elements which can stand alone and be referenced by id, e.g. cell, + * morphology. + * + * @nosubgrouping + */ + class Standalone: public ::neuroml2::Base + { + public: + /** + * @name notes + * + * @brief Accessor and modifier functions for the %notes + * optional element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::Notes notes_type; + + /** + * @brief Element optional container type. + */ + typedef ::xsd::cxx::tree::optional< notes_type > notes_optional; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< notes_type, char > notes_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * container. + * + * @return A constant reference to the optional container. + */ + const notes_optional& + notes () const; + + /** + * @brief Return a read-write reference to the element container. + * + * @return A reference to the optional container. + */ + notes_optional& + notes (); + + /** + * @brief Set the element value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. + */ + void + notes (const notes_type& x); + + /** + * @brief Set the element value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. + */ + void + notes (const notes_optional& x); + + /** + * @brief Set the element value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + notes (::std::unique_ptr< notes_type > p); + + //@} + + /** + * @name property + * + * @brief Accessor and modifier functions for the %property + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::Property property_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< property_type > property_sequence; + + /** + * @brief Element iterator type. + */ + typedef property_sequence::iterator property_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef property_sequence::const_iterator property_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< property_type, char > property_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const property_sequence& + property () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + property_sequence& + property (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + property (const property_sequence& s); + + //@} + + /** + * @name annotation + * + * @brief Accessor and modifier functions for the %annotation + * optional element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::Annotation annotation_type; + + /** + * @brief Element optional container type. + */ + typedef ::xsd::cxx::tree::optional< annotation_type > annotation_optional; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< annotation_type, char > annotation_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * container. + * + * @return A constant reference to the optional container. + */ + const annotation_optional& + annotation () const; + + /** + * @brief Return a read-write reference to the element container. + * + * @return A reference to the optional container. + */ + annotation_optional& + annotation (); + + /** + * @brief Set the element value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. + */ + void + annotation (const annotation_type& x); + + /** + * @brief Set the element value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. + */ + void + annotation (const annotation_optional& x); + + /** + * @brief Set the element value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + annotation (::std::unique_ptr< annotation_type > p); + + //@} + + /** + * @name metaid + * + * @brief Accessor and modifier functions for the %metaid + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::MetaId metaid_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< metaid_type > metaid_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< metaid_type, char > metaid_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. + */ + const metaid_optional& + metaid () const; + + /** + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. + */ + metaid_optional& + metaid (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + metaid (const metaid_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + metaid (const metaid_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + metaid (::std::unique_ptr< metaid_type > p); + + //@} + + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + Standalone (const id_type&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + Standalone (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + Standalone (const Standalone& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual Standalone* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + /** + * @brief Copy assignment operator. + * + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. + */ + Standalone& + operator= (const Standalone& x); + + //@} + + /** + * @brief Destructor. + */ + virtual + ~Standalone (); + + // Implementation. + // + + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + notes_optional notes_; + property_sequence property_; + annotation_optional annotation_; + metaid_optional metaid_; + + //@endcond + }; + + bool + operator== (const Standalone&, const Standalone&); + + bool + operator!= (const Standalone&, const Standalone&); + + + /** + * @brief Class corresponding to the %NeuroMLDocument schema type. + * + * @nosubgrouping + */ + class NeuroMLDocument_base: public ::neuroml2::Standalone + { + public: + /** + * @name include + * + * @brief Accessor and modifier functions for the %include + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::IncludeType include_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< include_type > include_sequence; + + /** + * @brief Element iterator type. + */ + typedef include_sequence::iterator include_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef include_sequence::const_iterator include_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< include_type, char > include_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const include_sequence& + include () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + include_sequence& + include (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + include (const include_sequence& s); + + //@} + + /** + * @name extracellularProperties + * + * @brief Accessor and modifier functions for the %extracellularProperties + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::ExtracellularProperties extracellularProperties_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< extracellularProperties_type > extracellularProperties_sequence; + + /** + * @brief Element iterator type. + */ + typedef extracellularProperties_sequence::iterator extracellularProperties_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef extracellularProperties_sequence::const_iterator extracellularProperties_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< extracellularProperties_type, char > extracellularProperties_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const extracellularProperties_sequence& + extracellularProperties () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + extracellularProperties_sequence& + extracellularProperties (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + extracellularProperties (const extracellularProperties_sequence& s); + + //@} + + /** + * @name intracellularProperties + * + * @brief Accessor and modifier functions for the %intracellularProperties + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::IntracellularProperties intracellularProperties_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< intracellularProperties_type > intracellularProperties_sequence; + + /** + * @brief Element iterator type. + */ + typedef intracellularProperties_sequence::iterator intracellularProperties_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef intracellularProperties_sequence::const_iterator intracellularProperties_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< intracellularProperties_type, char > intracellularProperties_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const intracellularProperties_sequence& + intracellularProperties () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + intracellularProperties_sequence& + intracellularProperties (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + intracellularProperties (const intracellularProperties_sequence& s); + + //@} + + /** + * @name morphology + * + * @brief Accessor and modifier functions for the %morphology + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::Morphology morphology_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< morphology_type > morphology_sequence; + + /** + * @brief Element iterator type. + */ + typedef morphology_sequence::iterator morphology_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef morphology_sequence::const_iterator morphology_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< morphology_type, char > morphology_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const morphology_sequence& + morphology () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + morphology_sequence& + morphology (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + morphology (const morphology_sequence& s); + + //@} + + /** + * @name ionChannel + * + * @brief Accessor and modifier functions for the %ionChannel + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::IonChannel ionChannel_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< ionChannel_type > ionChannel_sequence; + + /** + * @brief Element iterator type. + */ + typedef ionChannel_sequence::iterator ionChannel_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef ionChannel_sequence::const_iterator ionChannel_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< ionChannel_type, char > ionChannel_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const ionChannel_sequence& + ionChannel () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + ionChannel_sequence& + ionChannel (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + ionChannel (const ionChannel_sequence& s); + + //@} + + /** + * @name ionChannelHH + * + * @brief Accessor and modifier functions for the %ionChannelHH + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::IonChannelHH ionChannelHH_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< ionChannelHH_type > ionChannelHH_sequence; + + /** + * @brief Element iterator type. + */ + typedef ionChannelHH_sequence::iterator ionChannelHH_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef ionChannelHH_sequence::const_iterator ionChannelHH_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< ionChannelHH_type, char > ionChannelHH_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const ionChannelHH_sequence& + ionChannelHH () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + ionChannelHH_sequence& + ionChannelHH (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + ionChannelHH (const ionChannelHH_sequence& s); + + //@} + + /** + * @name ionChannelVShift + * + * @brief Accessor and modifier functions for the %ionChannelVShift + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::IonChannelVShift ionChannelVShift_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< ionChannelVShift_type > ionChannelVShift_sequence; + + /** + * @brief Element iterator type. + */ + typedef ionChannelVShift_sequence::iterator ionChannelVShift_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef ionChannelVShift_sequence::const_iterator ionChannelVShift_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< ionChannelVShift_type, char > ionChannelVShift_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const ionChannelVShift_sequence& + ionChannelVShift () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + ionChannelVShift_sequence& + ionChannelVShift (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + ionChannelVShift (const ionChannelVShift_sequence& s); + + //@} + + /** + * @name ionChannelKS + * + * @brief Accessor and modifier functions for the %ionChannelKS + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::IonChannelKS ionChannelKS_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< ionChannelKS_type > ionChannelKS_sequence; + + /** + * @brief Element iterator type. + */ + typedef ionChannelKS_sequence::iterator ionChannelKS_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef ionChannelKS_sequence::const_iterator ionChannelKS_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< ionChannelKS_type, char > ionChannelKS_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const ionChannelKS_sequence& + ionChannelKS () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + ionChannelKS_sequence& + ionChannelKS (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + ionChannelKS (const ionChannelKS_sequence& s); + + //@} + + /** + * @name decayingPoolConcentrationModel + * + * @brief Accessor and modifier functions for the %decayingPoolConcentrationModel + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::DecayingPoolConcentrationModel decayingPoolConcentrationModel_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< decayingPoolConcentrationModel_type > decayingPoolConcentrationModel_sequence; + + /** + * @brief Element iterator type. + */ + typedef decayingPoolConcentrationModel_sequence::iterator decayingPoolConcentrationModel_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef decayingPoolConcentrationModel_sequence::const_iterator decayingPoolConcentrationModel_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< decayingPoolConcentrationModel_type, char > decayingPoolConcentrationModel_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const decayingPoolConcentrationModel_sequence& + decayingPoolConcentrationModel () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + decayingPoolConcentrationModel_sequence& + decayingPoolConcentrationModel (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + decayingPoolConcentrationModel (const decayingPoolConcentrationModel_sequence& s); + + //@} + + /** + * @name fixedFactorConcentrationModel + * + * @brief Accessor and modifier functions for the %fixedFactorConcentrationModel + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::FixedFactorConcentrationModel fixedFactorConcentrationModel_type; + + /** + * @brief Element sequence container type. */ typedef ::xsd::cxx::tree::sequence< fixedFactorConcentrationModel_type > fixedFactorConcentrationModel_sequence; @@ -11163,6 +13814,70 @@ namespace neuroml2 //@} + /** + * @name hindmarshRose1984Cell + * + * @brief Accessor and modifier functions for the %hindmarshRose1984Cell + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::HindmarshRose1984Cell hindmarshRose1984Cell_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< hindmarshRose1984Cell_type > hindmarshRose1984Cell_sequence; + + /** + * @brief Element iterator type. + */ + typedef hindmarshRose1984Cell_sequence::iterator hindmarshRose1984Cell_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef hindmarshRose1984Cell_sequence::const_iterator hindmarshRose1984Cell_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< hindmarshRose1984Cell_type, char > hindmarshRose1984Cell_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const hindmarshRose1984Cell_sequence& + hindmarshRose1984Cell () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + hindmarshRose1984Cell_sequence& + hindmarshRose1984Cell (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + hindmarshRose1984Cell (const hindmarshRose1984Cell_sequence& s); + + //@} + /** * @name pulseGenerator * @@ -13327,6 +16042,7 @@ namespace neuroml2 fitzHughNagumoCell_sequence fitzHughNagumoCell_; fitzHughNagumo1969Cell_sequence fitzHughNagumo1969Cell_; pinskyRinzelCA3Cell_sequence pinskyRinzelCA3Cell_; + hindmarshRose1984Cell_sequence hindmarshRose1984Cell_; pulseGenerator_sequence pulseGenerator_; pulseGeneratorDL_sequence pulseGeneratorDL_; sineGenerator_sequence sineGenerator_; @@ -13600,6 +16316,82 @@ namespace neuroml2 //@} + /** + * @name neuroLexId + * + * @brief Accessor and modifier functions for the %neuroLexId + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::NeuroLexId neuroLexId_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< neuroLexId_type > neuroLexId_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< neuroLexId_type, char > neuroLexId_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. + */ + const neuroLexId_optional& + neuroLexId () const; + + /** + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. + */ + neuroLexId_optional& + neuroLexId (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + neuroLexId (const neuroLexId_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + neuroLexId (const neuroLexId_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + neuroLexId (::std::unique_ptr< neuroLexId_type > p); + + //@} + /** * @name Constructors */ @@ -13682,6 +16474,7 @@ namespace neuroml2 protected: q10ConductanceScaling_sequence q10ConductanceScaling_; + neuroLexId_optional neuroLexId_; //@endcond }; @@ -13922,6 +16715,82 @@ namespace neuroml2 //@} + /** + * @name neuroLexId + * + * @brief Accessor and modifier functions for the %neuroLexId + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::NeuroLexId neuroLexId_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< neuroLexId_type > neuroLexId_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< neuroLexId_type, char > neuroLexId_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. + */ + const neuroLexId_optional& + neuroLexId () const; + + /** + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. + */ + neuroLexId_optional& + neuroLexId (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + neuroLexId (const neuroLexId_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + neuroLexId (const neuroLexId_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + neuroLexId (::std::unique_ptr< neuroLexId_type > p); + + //@} + /** * @name Constructors */ @@ -14006,6 +16875,7 @@ namespace neuroml2 gateKS_sequence gateKS_; species_optional species_; conductance_optional conductance_; + neuroLexId_optional neuroLexId_; //@endcond }; @@ -14744,30 +17614,279 @@ namespace neuroml2 * the new value of the attribute. */ void - conductance (const conductance_type& x); - - /** - * @brief Set the attribute value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. - */ - void - conductance (const conductance_optional& x); + conductance (const conductance_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + conductance (const conductance_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + conductance (::std::unique_ptr< conductance_type > p); + + //@} + + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + IonChannel (const id_type&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + IonChannel (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + IonChannel (const IonChannel& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual IonChannel* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + /** + * @brief Copy assignment operator. + * + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. + */ + IonChannel& + operator= (const IonChannel& x); + + //@} + + /** + * @brief Destructor. + */ + virtual + ~IonChannel (); + + // Implementation. + // + + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + gate_sequence gate_; + gateHHrates_sequence gateHHrates_; + gateHHratesTau_sequence gateHHratesTau_; + gateHHtauInf_sequence gateHHtauInf_; + gateHHratesInf_sequence gateHHratesInf_; + gateHHratesTauInf_sequence gateHHratesTauInf_; + gateHHInstantaneous_sequence gateHHInstantaneous_; + gateFractional_sequence gateFractional_; + species_optional species_; + type_optional type_; + conductance_optional conductance_; + + //@endcond + }; + + bool + operator== (const IonChannel&, const IonChannel&); + + bool + operator!= (const IonChannel&, const IonChannel&); + + + /** + * @brief Class corresponding to the %IonChannelHH schema type. + * + * Note **ionChannel** and **ionChannelHH** are currently + * functionally identical. This is needed since many existing examples + * use ionChannel, some use ionChannelHH. NeuroML v2beta4 should remove + * one of these, probably ionChannelHH. + * @param conductance + * + * @nosubgrouping + */ + class IonChannelHH: public ::neuroml2::IonChannel + { + public: + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + IonChannelHH (const id_type&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + IonChannelHH (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + IonChannelHH (const IonChannelHH& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual IonChannelHH* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + //@} + + /** + * @brief Destructor. + */ + virtual + ~IonChannelHH (); + }; + + /** + * @brief Class corresponding to the %IonChannelVShift schema type. + * + * Same as **ionChannel** , but with a **vShift** parameter to change + * voltage activation of gates. The exact usage of **vShift** in + * expressions for rates is determined by the individual gates. + * @param vShift + * @param conductance + * + * @nosubgrouping + */ + class IonChannelVShift: public ::neuroml2::IonChannel + { + public: + /** + * @name vShift + * + * @brief Accessor and modifier functions for the %vShift + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::Nml2Quantity_voltage vShift_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< vShift_type, char > vShift_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const vShift_type& + vShift () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + vShift_type& + vShift (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + vShift (const vShift_type& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - conductance (::std::unique_ptr< conductance_type > p); + vShift (::std::unique_ptr< vShift_type > p); //@} @@ -14780,7 +17899,8 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - IonChannel (const id_type&); + IonChannelVShift (const id_type&, + const vShift_type&); /** * @brief Create an instance from a DOM element. @@ -14790,9 +17910,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - IonChannel (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IonChannelVShift (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -14803,9 +17923,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IonChannel (const IonChannel& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IonChannelVShift (const IonChannelVShift& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -14818,7 +17938,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual IonChannel* + virtual IonChannelVShift* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -14830,8 +17950,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IonChannel& - operator= (const IonChannel& x); + IonChannelVShift& + operator= (const IonChannelVShift& x); //@} @@ -14839,7 +17959,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~IonChannel (); + ~IonChannelVShift (); // Implementation. // @@ -14852,52 +17972,62 @@ namespace neuroml2 ::xml_schema::flags); protected: - gate_sequence gate_; - gateHHrates_sequence gateHHrates_; - gateHHratesTau_sequence gateHHratesTau_; - gateHHtauInf_sequence gateHHtauInf_; - gateHHratesInf_sequence gateHHratesInf_; - gateHHratesTauInf_sequence gateHHratesTauInf_; - gateHHInstantaneous_sequence gateHHInstantaneous_; - gateFractional_sequence gateFractional_; - species_optional species_; - type_optional type_; - conductance_optional conductance_; + ::xsd::cxx::tree::one< vShift_type > vShift_; //@endcond }; bool - operator== (const IonChannel&, const IonChannel&); + operator== (const IonChannelVShift&, const IonChannelVShift&); bool - operator!= (const IonChannel&, const IonChannel&); + operator!= (const IonChannelVShift&, const IonChannelVShift&); /** - * @brief Class corresponding to the %IonChannelHH schema type. - * - * Note **ionChannel** and **ionChannelHH** are currently - * functionally identical. This is needed since many existing examples - * use ionChannel, some use ionChannelHH. NeuroML v2beta4 should remove - * one of these, probably ionChannelHH. - * @param conductance - * - * @nosubgrouping + * @brief Enumeration class corresponding to the %channelTypes + * schema type. */ - class IonChannelHH: public ::neuroml2::IonChannel + class channelTypes: public ::xml_schema::string { public: + /** - * @name Constructors + * @brief Underlying enum type. */ - //@{ + enum value + { + ionChannelPassive, + ionChannelHH + }; /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Create an instance from the underlying enum value. + * + * @param v A enum value. */ - IonChannelHH (const id_type&); + channelTypes (value v); + + /** + * @brief Create an instance from a C string. + * + * @param v A string value. + */ + channelTypes (const char* v); + + /** + * @brief Create an instance from a string. + * + * @param v A string value. + */ + channelTypes (const ::std::string& v); + + /** + * @brief Create an instance from the base value. + * + * @param v A base value. + */ + channelTypes (const ::xml_schema::string& v); /** * @brief Create an instance from a DOM element. @@ -14907,7 +18037,33 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - IonChannelHH (const ::xercesc::DOMElement& e, + channelTypes (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a DOM attribute. + * + * @param a A DOM attribute to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + channelTypes (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a string fragment. + * + * @param s A string fragment to extract the data from. + * @param e A pointer to DOM element containing the string fragment. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + channelTypes (const ::std::string& s, + const ::xercesc::DOMElement* e, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -14920,7 +18076,7 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IonChannelHH (const IonChannelHH& x, + channelTypes (const channelTypes& x, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -14935,37 +18091,63 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual IonChannelHH* + virtual channelTypes* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; - //@} + /** + * @brief Assign the underlying enum value. + * + * @param v A enum value. + * @return A refernce to the instance. + */ + channelTypes& + operator= (value v); /** - * @brief Destructor. + * @brief Implicit conversion operator to the underlying + * enum value. + * + * @return A enum value. */ - virtual - ~IonChannelHH (); + virtual + operator value () const + { + return _xsd_channelTypes_convert (); + } + + //@cond + + protected: + value + _xsd_channelTypes_convert () const; + + public: + static const char* const _xsd_channelTypes_literals_[2]; + static const value _xsd_channelTypes_indexes_[2]; + + //@endcond }; /** - * @brief Class corresponding to the %IonChannelVShift schema type. + * @brief Class corresponding to the %Q10ConductanceScaling schema type. * - * Same as **ionChannel** , but with a **vShift** parameter to change - * voltage activation of gates. The exact usage of **vShift** in - * expressions for rates is determined by the individual gates. - * @param vShift - * @param conductance + * A value for the conductance scaling which varies as a standard + * function of the difference between the current temperature, + * **temperature,** and the temperature at which the conductance was + * originally determined, **experimentalTemp** + * @param q10Factor + * @param experimentalTemp * * @nosubgrouping */ - class IonChannelVShift: public ::neuroml2::IonChannel + class Q10ConductanceScaling: public ::neuroml2::BaseWithoutId { public: /** - * @name vShift + * @name q10Factor * - * @brief Accessor and modifier functions for the %vShift + * @brief Accessor and modifier functions for the %q10Factor * required attribute. */ //@{ @@ -14973,28 +18155,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage vShift_type; + typedef ::neuroml2::Nml2Quantity_none q10Factor_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< vShift_type, char > vShift_traits; + typedef ::xsd::cxx::tree::traits< q10Factor_type, char > q10Factor_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const vShift_type& - vShift () const; + const q10Factor_type& + q10Factor () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - vShift_type& - vShift (); + q10Factor_type& + q10Factor (); /** * @brief Set the attribute value. @@ -15005,7 +18187,7 @@ namespace neuroml2 * the new value of the attribute. */ void - vShift (const vShift_type& x); + q10Factor (const q10Factor_type& x); /** * @brief Set the attribute value without copying. @@ -15016,7 +18198,65 @@ namespace neuroml2 * instead of making a copy. */ void - vShift (::std::unique_ptr< vShift_type > p); + q10Factor (::std::unique_ptr< q10Factor_type > p); + + //@} + + /** + * @name experimentalTemp + * + * @brief Accessor and modifier functions for the %experimentalTemp + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::Nml2Quantity_temperature experimentalTemp_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< experimentalTemp_type, char > experimentalTemp_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const experimentalTemp_type& + experimentalTemp () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + experimentalTemp_type& + experimentalTemp (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + experimentalTemp (const experimentalTemp_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + experimentalTemp (::std::unique_ptr< experimentalTemp_type > p); //@} @@ -15029,8 +18269,8 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - IonChannelVShift (const id_type&, - const vShift_type&); + Q10ConductanceScaling (const q10Factor_type&, + const experimentalTemp_type&); /** * @brief Create an instance from a DOM element. @@ -15040,9 +18280,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - IonChannelVShift (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + Q10ConductanceScaling (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -15053,9 +18293,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IonChannelVShift (const IonChannelVShift& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + Q10ConductanceScaling (const Q10ConductanceScaling& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -15068,7 +18308,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual IonChannelVShift* + virtual Q10ConductanceScaling* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -15080,8 +18320,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IonChannelVShift& - operator= (const IonChannelVShift& x); + Q10ConductanceScaling& + operator= (const Q10ConductanceScaling& x); //@} @@ -15089,7 +18329,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~IonChannelVShift (); + ~Q10ConductanceScaling (); // Implementation. // @@ -15102,23 +18342,24 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< vShift_type > vShift_; + ::xsd::cxx::tree::one< q10Factor_type > q10Factor_; + ::xsd::cxx::tree::one< experimentalTemp_type > experimentalTemp_; //@endcond }; bool - operator== (const IonChannelVShift&, const IonChannelVShift&); + operator== (const Q10ConductanceScaling&, const Q10ConductanceScaling&); bool - operator!= (const IonChannelVShift&, const IonChannelVShift&); + operator!= (const Q10ConductanceScaling&, const Q10ConductanceScaling&); /** - * @brief Enumeration class corresponding to the %channelTypes + * @brief Enumeration class corresponding to the %gateTypes * schema type. */ - class channelTypes: public ::xml_schema::string + class gateTypes: public ::xml_schema::string { public: @@ -15127,8 +18368,14 @@ namespace neuroml2 */ enum value { - ionChannelPassive, - ionChannelHH + gateHHrates, + gateHHratesTau, + gateHHtauInf, + gateHHratesInf, + gateHHratesTauInf, + gateHHInstantaneous, + gateKS, + gateFractional }; /** @@ -15136,28 +18383,221 @@ namespace neuroml2 * * @param v A enum value. */ - channelTypes (value v); + gateTypes (value v); /** * @brief Create an instance from a C string. * * @param v A string value. */ - channelTypes (const char* v); + gateTypes (const char* v); + + /** + * @brief Create an instance from a string. + * + * @param v A string value. + */ + gateTypes (const ::std::string& v); + + /** + * @brief Create an instance from the base value. + * + * @param v A base value. + */ + gateTypes (const ::xml_schema::string& v); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + gateTypes (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a DOM attribute. + * + * @param a A DOM attribute to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + gateTypes (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Create an instance from a string fragment. + * + * @param s A string fragment to extract the data from. + * @param e A pointer to DOM element containing the string fragment. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + gateTypes (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + gateTypes (const gateTypes& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual gateTypes* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + /** + * @brief Assign the underlying enum value. + * + * @param v A enum value. + * @return A refernce to the instance. + */ + gateTypes& + operator= (value v); + + /** + * @brief Implicit conversion operator to the underlying + * enum value. + * + * @return A enum value. + */ + virtual + operator value () const + { + return _xsd_gateTypes_convert (); + } + + //@cond + + protected: + value + _xsd_gateTypes_convert () const; + + public: + static const char* const _xsd_gateTypes_literals_[8]; + static const value _xsd_gateTypes_indexes_[8]; + + //@endcond + }; + + /** + * @brief Class corresponding to the %ClosedState schema type. + * + * A **KSState** with **relativeConductance** of 0 + * @param relativeConductance + * + * @nosubgrouping + */ + class ClosedState: public ::neuroml2::Base + { + public: + /** + * @name Constructors + */ + //@{ /** - * @brief Create an instance from a string. - * - * @param v A string value. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + ClosedState (const id_type&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + ClosedState (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + ClosedState (const ClosedState& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual ClosedState* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + //@} + + /** + * @brief Destructor. + */ + virtual + ~ClosedState (); + }; + + /** + * @brief Class corresponding to the %OpenState schema type. + * + * A **KSState** with **relativeConductance** of 1 + * @param relativeConductance + * + * @nosubgrouping + */ + class OpenState: public ::neuroml2::Base + { + public: + /** + * @name Constructors */ - channelTypes (const ::std::string& v); + //@{ /** - * @brief Create an instance from the base value. - * - * @param v A base value. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. */ - channelTypes (const ::xml_schema::string& v); + OpenState (const id_type&); /** * @brief Create an instance from a DOM element. @@ -15167,35 +18607,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - channelTypes (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Create an instance from a DOM attribute. - * - * @param a A DOM attribute to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. - */ - channelTypes (const ::xercesc::DOMAttr& a, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Create an instance from a string fragment. - * - * @param s A string fragment to extract the data from. - * @param e A pointer to DOM element containing the string fragment. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. - */ - channelTypes (const ::std::string& s, - const ::xercesc::DOMElement* e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + OpenState (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -15206,9 +18620,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - channelTypes (const channelTypes& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + OpenState (const OpenState& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -15221,62 +18635,36 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual channelTypes* + virtual OpenState* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; - /** - * @brief Assign the underlying enum value. - * - * @param v A enum value. - * @return A refernce to the instance. - */ - channelTypes& - operator= (value v); + //@} /** - * @brief Implicit conversion operator to the underlying - * enum value. - * - * @return A enum value. + * @brief Destructor. */ - virtual - operator value () const - { - return _xsd_channelTypes_convert (); - } - - //@cond - - protected: - value - _xsd_channelTypes_convert () const; - - public: - static const char* const _xsd_channelTypes_literals_[2]; - static const value _xsd_channelTypes_indexes_[2]; - - //@endcond + virtual + ~OpenState (); }; /** - * @brief Class corresponding to the %Q10ConductanceScaling schema type. + * @brief Class corresponding to the %ForwardTransition schema type. * - * A value for the conductance scaling which varies as a standard - * function of the difference between the current temperature, - * **temperature,** and the temperature at which the conductance was - * originally determined, **experimentalTemp** - * @param q10Factor - * @param experimentalTemp + * A forward only **KSTransition** for a **gateKS** which specifies a + * **rate** ( type **baseHHRate** ) which follows one of the standard + * Hodgkin Huxley forms ( e. g. **HHExpRate** , **HHSigmoidRate** , + * **HHExpLinearRate** * * @nosubgrouping */ + class ForwardTransition: public ::neuroml2::Base { public: /** - * @name q10Factor + * @name from * - * @brief Accessor and modifier functions for the %q10Factor + * @brief Accessor and modifier functions for the %from * required attribute. */ //@{ @@ -15284,28 +18672,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none q10Factor_type; + typedef ::neuroml2::NmlId from_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< q10Factor_type, char > q10Factor_traits; + typedef ::xsd::cxx::tree::traits< from_type, char > from_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const q10Factor_type& - q10Factor () const; + const from_type& + from () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - q10Factor_type& - q10Factor (); + from_type& + from (); /** * @brief Set the attribute value. @@ -15316,7 +18704,7 @@ namespace neuroml2 * the new value of the attribute. */ void - q10Factor (const q10Factor_type& x); + from (const from_type& x); /** * @brief Set the attribute value without copying. @@ -15327,14 +18715,14 @@ namespace neuroml2 * instead of making a copy. */ void - q10Factor (::std::unique_ptr< q10Factor_type > p); + from (::std::unique_ptr< from_type > p); //@} /** - * @name experimentalTemp + * @name to * - * @brief Accessor and modifier functions for the %experimentalTemp + * @brief Accessor and modifier functions for the %to * required attribute. */ //@{ @@ -15342,28 +18730,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_temperature experimentalTemp_type; + typedef ::neuroml2::NmlId to_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< experimentalTemp_type, char > experimentalTemp_traits; + typedef ::xsd::cxx::tree::traits< to_type, char > to_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const experimentalTemp_type& - experimentalTemp () const; + const to_type& + to () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - experimentalTemp_type& - experimentalTemp (); + to_type& + to (); /** * @brief Set the attribute value. @@ -15374,7 +18762,7 @@ namespace neuroml2 * the new value of the attribute. */ void - experimentalTemp (const experimentalTemp_type& x); + to (const to_type& x); /** * @brief Set the attribute value without copying. @@ -15385,7 +18773,7 @@ namespace neuroml2 * instead of making a copy. */ void - experimentalTemp (::std::unique_ptr< experimentalTemp_type > p); + to (::std::unique_ptr< to_type > p); //@} @@ -15398,8 +18786,9 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - Q10ConductanceScaling (const q10Factor_type&, - const experimentalTemp_type&); + ForwardTransition (const id_type&, + const from_type&, + const to_type&); /** * @brief Create an instance from a DOM element. @@ -15409,9 +18798,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - Q10ConductanceScaling (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + ForwardTransition (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -15422,9 +18811,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - Q10ConductanceScaling (const Q10ConductanceScaling& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + ForwardTransition (const ForwardTransition& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -15437,7 +18826,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual Q10ConductanceScaling* + virtual ForwardTransition* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -15449,8 +18838,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - Q10ConductanceScaling& - operator= (const Q10ConductanceScaling& x); + ForwardTransition& + operator= (const ForwardTransition& x); //@} @@ -15458,7 +18847,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~Q10ConductanceScaling (); + ~ForwardTransition (); // Implementation. // @@ -15471,107 +18860,172 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< q10Factor_type > q10Factor_; - ::xsd::cxx::tree::one< experimentalTemp_type > experimentalTemp_; + ::xsd::cxx::tree::one< from_type > from_; + ::xsd::cxx::tree::one< to_type > to_; //@endcond }; bool - operator== (const Q10ConductanceScaling&, const Q10ConductanceScaling&); + operator== (const ForwardTransition&, const ForwardTransition&); bool - operator!= (const Q10ConductanceScaling&, const Q10ConductanceScaling&); + operator!= (const ForwardTransition&, const ForwardTransition&); /** - * @brief Enumeration class corresponding to the %gateTypes - * schema type. + * @brief Class corresponding to the %ReverseTransition schema type. + * + * A reverse only **KSTransition** for a **gateKS** which specifies a + * **rate** ( type **baseHHRate** ) which follows one of the standard + * Hodgkin Huxley forms ( e. g. **HHExpRate** , **HHSigmoidRate** , + * **HHExpLinearRate** + * + * @nosubgrouping */ - class gateTypes: public ::xml_schema::string + class ReverseTransition: public ::neuroml2::Base { public: + /** + * @name from + * + * @brief Accessor and modifier functions for the %from + * required attribute. + */ + //@{ /** - * @brief Underlying enum type. + * @brief Attribute type. */ - enum value - { - gateHHrates, - gateHHratesTau, - gateHHtauInf, - gateHHratesInf, - gateHHratesTauInf, - gateHHInstantaneous, - gateKS, - gateFractional - }; + typedef ::neuroml2::NmlId from_type; /** - * @brief Create an instance from the underlying enum value. + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< from_type, char > from_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. * - * @param v A enum value. + * @return A constant reference to the attribute. */ - gateTypes (value v); + const from_type& + from () const; /** - * @brief Create an instance from a C string. + * @brief Return a read-write reference to the attribute. * - * @param v A string value. + * @return A reference to the attribute. */ - gateTypes (const char* v); + from_type& + from (); /** - * @brief Create an instance from a string. + * @brief Set the attribute value. * - * @param v A string value. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - gateTypes (const ::std::string& v); + void + from (const from_type& x); /** - * @brief Create an instance from the base value. + * @brief Set the attribute value without copying. * - * @param v A base value. + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. */ - gateTypes (const ::xml_schema::string& v); + void + from (::std::unique_ptr< from_type > p); + + //@} /** - * @brief Create an instance from a DOM element. + * @name to * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @brief Accessor and modifier functions for the %to + * required attribute. */ - gateTypes (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + //@{ /** - * @brief Create an instance from a DOM attribute. + * @brief Attribute type. + */ + typedef ::neuroml2::NmlId to_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< to_type, char > to_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. * - * @param a A DOM attribute to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @return A constant reference to the attribute. */ - gateTypes (const ::xercesc::DOMAttr& a, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + const to_type& + to () const; /** - * @brief Create an instance from a string fragment. + * @brief Return a read-write reference to the attribute. * - * @param s A string fragment to extract the data from. - * @param e A pointer to DOM element containing the string fragment. + * @return A reference to the attribute. + */ + to_type& + to (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + to (const to_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + to (::std::unique_ptr< to_type > p); + + //@} + + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + ReverseTransition (const id_type&, + const from_type&, + const to_type&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ - gateTypes (const ::std::string& s, - const ::xercesc::DOMElement* e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + ReverseTransition (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -15582,9 +19036,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - gateTypes (const gateTypes& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + ReverseTransition (const ReverseTransition& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -15597,199 +19051,180 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual gateTypes* + virtual ReverseTransition* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; /** - * @brief Assign the underlying enum value. + * @brief Copy assignment operator. * - * @param v A enum value. - * @return A refernce to the instance. + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. */ - gateTypes& - operator= (value v); + ReverseTransition& + operator= (const ReverseTransition& x); + + //@} /** - * @brief Implicit conversion operator to the underlying - * enum value. - * - * @return A enum value. + * @brief Destructor. */ - virtual - operator value () const - { - return _xsd_gateTypes_convert (); - } + virtual + ~ReverseTransition (); + + // Implementation. + // //@cond protected: - value - _xsd_gateTypes_convert () const; + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); - public: - static const char* const _xsd_gateTypes_literals_[8]; - static const value _xsd_gateTypes_indexes_[8]; + protected: + ::xsd::cxx::tree::one< from_type > from_; + ::xsd::cxx::tree::one< to_type > to_; //@endcond }; + bool + operator== (const ReverseTransition&, const ReverseTransition&); + + bool + operator!= (const ReverseTransition&, const ReverseTransition&); + + /** - * @brief Class corresponding to the %ClosedState schema type. + * @brief Class corresponding to the %TauInfTransition schema type. * - * A **KSState** with **relativeConductance** of 0 - * @param relativeConductance + * KS Transition specified in terms of time constant **tau** and steady + * state **inf** * * @nosubgrouping */ - class ClosedState: public ::neuroml2::Base + class TauInfTransition: public ::neuroml2::Base { public: /** - * @name Constructors + * @name steadyState + * + * @brief Accessor and modifier functions for the %steadyState + * required element. */ //@{ /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Element type. */ - ClosedState (const id_type&); + typedef ::neuroml2::HHVariable steadyState_type; /** - * @brief Create an instance from a DOM element. + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; + + /** + * @brief Return a read-only (constant) reference to the element. * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @return A constant reference to the element. */ - ClosedState (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + const steadyState_type& + steadyState () const; /** - * @brief Copy constructor. + * @brief Return a read-write reference to the element. * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. + * @return A reference to the element. + */ + steadyState_type& + steadyState (); + + /** + * @brief Set the element value. * - * For polymorphic object models use the @c _clone function instead. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. */ - ClosedState (const ClosedState& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + void + steadyState (const steadyState_type& x); /** - * @brief Copy the instance polymorphically. + * @brief Set the element value without copying. * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. + * @param p A new value to use. * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. + * This function will try to use the passed value directly + * instead of making a copy. */ - virtual ClosedState* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; + void + steadyState (::std::unique_ptr< steadyState_type > p); //@} /** - * @brief Destructor. + * @name timeCourse + * + * @brief Accessor and modifier functions for the %timeCourse + * required element. */ - virtual - ~ClosedState (); - }; + //@{ - /** - * @brief Class corresponding to the %OpenState schema type. - * - * A **KSState** with **relativeConductance** of 1 - * @param relativeConductance - * - * @nosubgrouping - */ - class OpenState: public ::neuroml2::Base - { - public: /** - * @name Constructors + * @brief Element type. */ - //@{ + typedef ::neuroml2::HHTime timeCourse_type; /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Element traits type. */ - OpenState (const id_type&); + typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; /** - * @brief Create an instance from a DOM element. + * @brief Return a read-only (constant) reference to the element. * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @return A constant reference to the element. */ - OpenState (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + const timeCourse_type& + timeCourse () const; + + /** + * @brief Return a read-write reference to the element. + * + * @return A reference to the element. + */ + timeCourse_type& + timeCourse (); /** - * @brief Copy constructor. + * @brief Set the element value. * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. + * @param x A new value to set. * - * For polymorphic object models use the @c _clone function instead. + * This function makes a copy of its argument and sets it as + * the new value of the element. */ - OpenState (const OpenState& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + void + timeCourse (const timeCourse_type& x); /** - * @brief Copy the instance polymorphically. + * @brief Set the element value without copying. * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. + * @param p A new value to use. * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. + * This function will try to use the passed value directly + * instead of making a copy. */ - virtual OpenState* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; + void + timeCourse (::std::unique_ptr< timeCourse_type > p); //@} - /** - * @brief Destructor. - */ - virtual - ~OpenState (); - }; - - /** - * @brief Class corresponding to the %ForwardTransition schema type. - * - * A forward only **KSTransition** for a **gateKS** which specifies a - * **rate** ( type **baseHHRate** ) which follows one of the standard - * Hodgkin Huxley forms ( e. g. **HHExpRate** , **HHSigmoidRate** , - * **HHExpLinearRate** - * - * @nosubgrouping - */ - class ForwardTransition: public ::neuroml2::Base - { - public: /** * @name from * @@ -15915,9 +19350,25 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - ForwardTransition (const id_type&, - const from_type&, - const to_type&); + TauInfTransition (const id_type&, + const steadyState_type&, + const timeCourse_type&, + const from_type&, + const to_type&); + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes + * (::std::unique_ptr version). + * + * This constructor will try to use the passed values directly + * instead of making copies. + */ + TauInfTransition (const id_type&, + ::std::unique_ptr< steadyState_type >, + ::std::unique_ptr< timeCourse_type >, + const from_type&, + const to_type&); /** * @brief Create an instance from a DOM element. @@ -15927,9 +19378,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - ForwardTransition (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + TauInfTransition (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -15940,9 +19391,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - ForwardTransition (const ForwardTransition& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + TauInfTransition (const TauInfTransition& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -15955,7 +19406,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual ForwardTransition* + virtual TauInfTransition* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -15967,8 +19418,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - ForwardTransition& - operator= (const ForwardTransition& x); + TauInfTransition& + operator= (const TauInfTransition& x); //@} @@ -15976,7 +19427,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~ForwardTransition (); + ~TauInfTransition (); // Implementation. // @@ -15989,6 +19440,8 @@ namespace neuroml2 ::xml_schema::flags); protected: + ::xsd::cxx::tree::one< steadyState_type > steadyState_; + ::xsd::cxx::tree::one< timeCourse_type > timeCourse_; ::xsd::cxx::tree::one< from_type > from_; ::xsd::cxx::tree::one< to_type > to_; @@ -15996,426 +19449,500 @@ namespace neuroml2 }; bool - operator== (const ForwardTransition&, const ForwardTransition&); + operator== (const TauInfTransition&, const TauInfTransition&); bool - operator!= (const ForwardTransition&, const ForwardTransition&); + operator!= (const TauInfTransition&, const TauInfTransition&); /** - * @brief Class corresponding to the %ReverseTransition schema type. + * @brief Class corresponding to the %GateKS schema type. * - * A reverse only **KSTransition** for a **gateKS** which specifies a - * **rate** ( type **baseHHRate** ) which follows one of the standard - * Hodgkin Huxley forms ( e. g. **HHExpRate** , **HHSigmoidRate** , - * **HHExpLinearRate** + * A gate which consists of multiple **KSState** s and **KSTransition** + * s giving the rates of transition between them + * @param instances * * @nosubgrouping */ - class ReverseTransition: public ::neuroml2::Base + class GateKS: public ::neuroml2::Base { public: /** - * @name from + * @name notes * - * @brief Accessor and modifier functions for the %from - * required attribute. + * @brief Accessor and modifier functions for the %notes + * optional element. */ //@{ /** - * @brief Attribute type. + * @brief Element type. */ - typedef ::neuroml2::NmlId from_type; + typedef ::neuroml2::Notes notes_type; /** - * @brief Attribute traits type. + * @brief Element optional container type. */ - typedef ::xsd::cxx::tree::traits< from_type, char > from_traits; + typedef ::xsd::cxx::tree::optional< notes_type > notes_optional; /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< notes_type, char > notes_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * container. * - * @return A constant reference to the attribute. + * @return A constant reference to the optional container. */ - const from_type& - from () const; + const notes_optional& + notes () const; /** - * @brief Return a read-write reference to the attribute. + * @brief Return a read-write reference to the element container. * - * @return A reference to the attribute. + * @return A reference to the optional container. */ - from_type& - from (); + notes_optional& + notes (); /** - * @brief Set the attribute value. + * @brief Set the element value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * the new value of the element. */ void - from (const from_type& x); + notes (const notes_type& x); /** - * @brief Set the attribute value without copying. + * @brief Set the element value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. + */ + void + notes (const notes_optional& x); + + /** + * @brief Set the element value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - from (::std::unique_ptr< from_type > p); + notes (::std::unique_ptr< notes_type > p); //@} /** - * @name to + * @name q10Settings * - * @brief Accessor and modifier functions for the %to - * required attribute. + * @brief Accessor and modifier functions for the %q10Settings + * optional element. */ //@{ /** - * @brief Attribute type. + * @brief Element type. */ - typedef ::neuroml2::NmlId to_type; + typedef ::neuroml2::Q10Settings q10Settings_type; /** - * @brief Attribute traits type. + * @brief Element optional container type. */ - typedef ::xsd::cxx::tree::traits< to_type, char > to_traits; + typedef ::xsd::cxx::tree::optional< q10Settings_type > q10Settings_optional; /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< q10Settings_type, char > q10Settings_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * container. * - * @return A constant reference to the attribute. + * @return A constant reference to the optional container. */ - const to_type& - to () const; + const q10Settings_optional& + q10Settings () const; /** - * @brief Return a read-write reference to the attribute. + * @brief Return a read-write reference to the element container. * - * @return A reference to the attribute. + * @return A reference to the optional container. */ - to_type& - to (); + q10Settings_optional& + q10Settings (); /** - * @brief Set the attribute value. + * @brief Set the element value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * the new value of the element. */ void - to (const to_type& x); + q10Settings (const q10Settings_type& x); /** - * @brief Set the attribute value without copying. + * @brief Set the element value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. + */ + void + q10Settings (const q10Settings_optional& x); + + /** + * @brief Set the element value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - to (::std::unique_ptr< to_type > p); + q10Settings (::std::unique_ptr< q10Settings_type > p); //@} /** - * @name Constructors + * @name closedState + * + * @brief Accessor and modifier functions for the %closedState + * sequence element. */ //@{ /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Element type. */ - ReverseTransition (const id_type&, - const from_type&, - const to_type&); + typedef ::neuroml2::ClosedState closedState_type; /** - * @brief Create an instance from a DOM element. - * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @brief Element sequence container type. */ - ReverseTransition (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + typedef ::xsd::cxx::tree::sequence< closedState_type > closedState_sequence; /** - * @brief Copy constructor. - * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * - * For polymorphic object models use the @c _clone function instead. + * @brief Element iterator type. */ - ReverseTransition (const ReverseTransition& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + typedef closedState_sequence::iterator closedState_iterator; /** - * @brief Copy the instance polymorphically. + * @brief Element constant iterator type. + */ + typedef closedState_sequence::const_iterator closedState_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< closedState_type, char > closedState_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. + * @return A constant reference to the sequence container. + */ + const closedState_sequence& + closedState () const; + + /** + * @brief Return a read-write reference to the element sequence. * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. + * @return A reference to the sequence container. */ - virtual ReverseTransition* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; + closedState_sequence& + closedState (); /** - * @brief Copy assignment operator. + * @brief Copy elements from a given sequence. * - * @param x An instance to make a copy of. - * @return A reference to itself. + * @param s A sequence to copy elements from. * - * For polymorphic object models use the @c _clone function instead. + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. */ - ReverseTransition& - operator= (const ReverseTransition& x); + void + closedState (const closedState_sequence& s); //@} /** - * @brief Destructor. + * @name openState + * + * @brief Accessor and modifier functions for the %openState + * sequence element. */ - virtual - ~ReverseTransition (); + //@{ - // Implementation. - // + /** + * @brief Element type. + */ + typedef ::neuroml2::OpenState openState_type; - //@cond + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< openState_type > openState_sequence; - protected: - void - parse (::xsd::cxx::xml::dom::parser< char >&, - ::xml_schema::flags); + /** + * @brief Element iterator type. + */ + typedef openState_sequence::iterator openState_iterator; - protected: - ::xsd::cxx::tree::one< from_type > from_; - ::xsd::cxx::tree::one< to_type > to_; + /** + * @brief Element constant iterator type. + */ + typedef openState_sequence::const_iterator openState_const_iterator; - //@endcond - }; + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< openState_type, char > openState_traits; - bool - operator== (const ReverseTransition&, const ReverseTransition&); + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const openState_sequence& + openState () const; - bool - operator!= (const ReverseTransition&, const ReverseTransition&); + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + openState_sequence& + openState (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + openState (const openState_sequence& s); + //@} - /** - * @brief Class corresponding to the %TauInfTransition schema type. - * - * KS Transition specified in terms of time constant **tau** and steady - * state **inf** - * - * @nosubgrouping - */ - class TauInfTransition: public ::neuroml2::Base - { - public: /** - * @name steadyState + * @name forwardTransition * - * @brief Accessor and modifier functions for the %steadyState - * required element. + * @brief Accessor and modifier functions for the %forwardTransition + * sequence element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::HHVariable steadyState_type; + typedef ::neuroml2::ForwardTransition forwardTransition_type; /** - * @brief Element traits type. + * @brief Element sequence container type. */ - typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; + typedef ::xsd::cxx::tree::sequence< forwardTransition_type > forwardTransition_sequence; /** - * @brief Return a read-only (constant) reference to the element. - * - * @return A constant reference to the element. + * @brief Element iterator type. */ - const steadyState_type& - steadyState () const; + typedef forwardTransition_sequence::iterator forwardTransition_iterator; /** - * @brief Return a read-write reference to the element. - * - * @return A reference to the element. + * @brief Element constant iterator type. */ - steadyState_type& - steadyState (); + typedef forwardTransition_sequence::const_iterator forwardTransition_const_iterator; /** - * @brief Set the element value. + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< forwardTransition_type, char > forwardTransition_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. * - * @param x A new value to set. + * @return A constant reference to the sequence container. + */ + const forwardTransition_sequence& + forwardTransition () const; + + /** + * @brief Return a read-write reference to the element sequence. * - * This function makes a copy of its argument and sets it as - * the new value of the element. + * @return A reference to the sequence container. */ - void - steadyState (const steadyState_type& x); + forwardTransition_sequence& + forwardTransition (); /** - * @brief Set the element value without copying. + * @brief Copy elements from a given sequence. * - * @param p A new value to use. + * @param s A sequence to copy elements from. * - * This function will try to use the passed value directly - * instead of making a copy. + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. */ void - steadyState (::std::unique_ptr< steadyState_type > p); + forwardTransition (const forwardTransition_sequence& s); //@} /** - * @name timeCourse + * @name reverseTransition * - * @brief Accessor and modifier functions for the %timeCourse - * required element. + * @brief Accessor and modifier functions for the %reverseTransition + * sequence element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::HHTime timeCourse_type; + typedef ::neuroml2::ReverseTransition reverseTransition_type; /** - * @brief Element traits type. + * @brief Element sequence container type. */ - typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; + typedef ::xsd::cxx::tree::sequence< reverseTransition_type > reverseTransition_sequence; /** - * @brief Return a read-only (constant) reference to the element. - * - * @return A constant reference to the element. + * @brief Element iterator type. */ - const timeCourse_type& - timeCourse () const; + typedef reverseTransition_sequence::iterator reverseTransition_iterator; /** - * @brief Return a read-write reference to the element. - * - * @return A reference to the element. + * @brief Element constant iterator type. */ - timeCourse_type& - timeCourse (); + typedef reverseTransition_sequence::const_iterator reverseTransition_const_iterator; /** - * @brief Set the element value. + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< reverseTransition_type, char > reverseTransition_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. * - * @param x A new value to set. + * @return A constant reference to the sequence container. + */ + const reverseTransition_sequence& + reverseTransition () const; + + /** + * @brief Return a read-write reference to the element sequence. * - * This function makes a copy of its argument and sets it as - * the new value of the element. + * @return A reference to the sequence container. */ - void - timeCourse (const timeCourse_type& x); + reverseTransition_sequence& + reverseTransition (); /** - * @brief Set the element value without copying. + * @brief Copy elements from a given sequence. * - * @param p A new value to use. + * @param s A sequence to copy elements from. * - * This function will try to use the passed value directly - * instead of making a copy. + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. */ void - timeCourse (::std::unique_ptr< timeCourse_type > p); + reverseTransition (const reverseTransition_sequence& s); //@} /** - * @name from + * @name tauInfTransition * - * @brief Accessor and modifier functions for the %from - * required attribute. + * @brief Accessor and modifier functions for the %tauInfTransition + * sequence element. */ //@{ /** - * @brief Attribute type. + * @brief Element type. */ - typedef ::neuroml2::NmlId from_type; + typedef ::neuroml2::TauInfTransition tauInfTransition_type; /** - * @brief Attribute traits type. + * @brief Element sequence container type. */ - typedef ::xsd::cxx::tree::traits< from_type, char > from_traits; + typedef ::xsd::cxx::tree::sequence< tauInfTransition_type > tauInfTransition_sequence; /** - * @brief Return a read-only (constant) reference to the attribute. - * - * @return A constant reference to the attribute. + * @brief Element iterator type. */ - const from_type& - from () const; + typedef tauInfTransition_sequence::iterator tauInfTransition_iterator; /** - * @brief Return a read-write reference to the attribute. - * - * @return A reference to the attribute. + * @brief Element constant iterator type. */ - from_type& - from (); + typedef tauInfTransition_sequence::const_iterator tauInfTransition_const_iterator; /** - * @brief Set the attribute value. + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< tauInfTransition_type, char > tauInfTransition_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. * - * @param x A new value to set. + * @return A constant reference to the sequence container. + */ + const tauInfTransition_sequence& + tauInfTransition () const; + + /** + * @brief Return a read-write reference to the element sequence. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * @return A reference to the sequence container. */ - void - from (const from_type& x); + tauInfTransition_sequence& + tauInfTransition (); /** - * @brief Set the attribute value without copying. + * @brief Copy elements from a given sequence. * - * @param p A new value to use. + * @param s A sequence to copy elements from. * - * This function will try to use the passed value directly - * instead of making a copy. + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. */ void - from (::std::unique_ptr< from_type > p); + tauInfTransition (const tauInfTransition_sequence& s); //@} /** - * @name to + * @name instances * - * @brief Accessor and modifier functions for the %to + * @brief Accessor and modifier functions for the %instances * required attribute. */ //@{ @@ -16423,28 +19950,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::NmlId to_type; + typedef ::neuroml2::PositiveInteger instances_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< to_type, char > to_traits; + typedef ::xsd::cxx::tree::traits< instances_type, char > instances_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const to_type& - to () const; + const instances_type& + instances () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - to_type& - to (); + instances_type& + instances (); /** * @brief Set the attribute value. @@ -16455,7 +19982,7 @@ namespace neuroml2 * the new value of the attribute. */ void - to (const to_type& x); + instances (const instances_type& x); /** * @brief Set the attribute value without copying. @@ -16466,7 +19993,7 @@ namespace neuroml2 * instead of making a copy. */ void - to (::std::unique_ptr< to_type > p); + instances (::std::unique_ptr< instances_type > p); //@} @@ -16479,25 +20006,8 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - TauInfTransition (const id_type&, - const steadyState_type&, - const timeCourse_type&, - const from_type&, - const to_type&); - - /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes - * (::std::unique_ptr version). - * - * This constructor will try to use the passed values directly - * instead of making copies. - */ - TauInfTransition (const id_type&, - ::std::unique_ptr< steadyState_type >, - ::std::unique_ptr< timeCourse_type >, - const from_type&, - const to_type&); + GateKS (const id_type&, + const instances_type&); /** * @brief Create an instance from a DOM element. @@ -16507,9 +20017,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - TauInfTransition (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateKS (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -16520,9 +20030,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - TauInfTransition (const TauInfTransition& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateKS (const GateKS& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -16535,7 +20045,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual TauInfTransition* + virtual GateKS* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -16547,8 +20057,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - TauInfTransition& - operator= (const TauInfTransition& x); + GateKS& + operator= (const GateKS& x); //@} @@ -16556,7 +20066,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~TauInfTransition (); + ~GateKS (); // Implementation. // @@ -16569,31 +20079,35 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< steadyState_type > steadyState_; - ::xsd::cxx::tree::one< timeCourse_type > timeCourse_; - ::xsd::cxx::tree::one< from_type > from_; - ::xsd::cxx::tree::one< to_type > to_; + notes_optional notes_; + q10Settings_optional q10Settings_; + closedState_sequence closedState_; + openState_sequence openState_; + forwardTransition_sequence forwardTransition_; + reverseTransition_sequence reverseTransition_; + tauInfTransition_sequence tauInfTransition_; + ::xsd::cxx::tree::one< instances_type > instances_; //@endcond }; bool - operator== (const TauInfTransition&, const TauInfTransition&); + operator== (const GateKS&, const GateKS&); bool - operator!= (const TauInfTransition&, const TauInfTransition&); + operator!= (const GateKS&, const GateKS&); /** - * @brief Class corresponding to the %GateKS schema type. + * @brief Class corresponding to the %GateHHUndetermined schema type. * - * A gate which consists of multiple **KSState** s and **KSTransition** - * s giving the rates of transition between them - * @param instances + * Note all sub elements for gateHHrates, gateHHratesTau, gateFractional + * etc. allowed here. Which are valid should be constrained by what type + * is set * * @nosubgrouping */ - class GateKS: public ::neuroml2::Base + class GateHHUndetermined: public ::neuroml2::Base { public: /** @@ -16749,265 +20263,313 @@ namespace neuroml2 //@} /** - * @name closedState + * @name forwardRate * - * @brief Accessor and modifier functions for the %closedState - * sequence element. + * @brief Accessor and modifier functions for the %forwardRate + * optional element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::ClosedState closedState_type; + typedef ::neuroml2::HHRate forwardRate_type; /** - * @brief Element sequence container type. + * @brief Element optional container type. */ - typedef ::xsd::cxx::tree::sequence< closedState_type > closedState_sequence; + typedef ::xsd::cxx::tree::optional< forwardRate_type > forwardRate_optional; /** - * @brief Element iterator type. + * @brief Element traits type. */ - typedef closedState_sequence::iterator closedState_iterator; + typedef ::xsd::cxx::tree::traits< forwardRate_type, char > forwardRate_traits; /** - * @brief Element constant iterator type. + * @brief Return a read-only (constant) reference to the element + * container. + * + * @return A constant reference to the optional container. */ - typedef closedState_sequence::const_iterator closedState_const_iterator; + const forwardRate_optional& + forwardRate () const; /** - * @brief Element traits type. + * @brief Return a read-write reference to the element container. + * + * @return A reference to the optional container. */ - typedef ::xsd::cxx::tree::traits< closedState_type, char > closedState_traits; + forwardRate_optional& + forwardRate (); /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Set the element value. * - * @return A constant reference to the sequence container. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. */ - const closedState_sequence& - closedState () const; + void + forwardRate (const forwardRate_type& x); /** - * @brief Return a read-write reference to the element sequence. + * @brief Set the element value. * - * @return A reference to the sequence container. + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. */ - closedState_sequence& - closedState (); + void + forwardRate (const forwardRate_optional& x); /** - * @brief Copy elements from a given sequence. + * @brief Set the element value without copying. * - * @param s A sequence to copy elements from. + * @param p A new value to use. * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * This function will try to use the passed value directly instead + * of making a copy. */ void - closedState (const closedState_sequence& s); + forwardRate (::std::unique_ptr< forwardRate_type > p); //@} /** - * @name openState + * @name reverseRate * - * @brief Accessor and modifier functions for the %openState - * sequence element. + * @brief Accessor and modifier functions for the %reverseRate + * optional element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::OpenState openState_type; + typedef ::neuroml2::HHRate reverseRate_type; /** - * @brief Element sequence container type. + * @brief Element optional container type. */ - typedef ::xsd::cxx::tree::sequence< openState_type > openState_sequence; + typedef ::xsd::cxx::tree::optional< reverseRate_type > reverseRate_optional; /** - * @brief Element iterator type. + * @brief Element traits type. */ - typedef openState_sequence::iterator openState_iterator; + typedef ::xsd::cxx::tree::traits< reverseRate_type, char > reverseRate_traits; /** - * @brief Element constant iterator type. + * @brief Return a read-only (constant) reference to the element + * container. + * + * @return A constant reference to the optional container. */ - typedef openState_sequence::const_iterator openState_const_iterator; + const reverseRate_optional& + reverseRate () const; /** - * @brief Element traits type. + * @brief Return a read-write reference to the element container. + * + * @return A reference to the optional container. */ - typedef ::xsd::cxx::tree::traits< openState_type, char > openState_traits; + reverseRate_optional& + reverseRate (); /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Set the element value. * - * @return A constant reference to the sequence container. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. */ - const openState_sequence& - openState () const; + void + reverseRate (const reverseRate_type& x); /** - * @brief Return a read-write reference to the element sequence. + * @brief Set the element value. * - * @return A reference to the sequence container. + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. */ - openState_sequence& - openState (); + void + reverseRate (const reverseRate_optional& x); /** - * @brief Copy elements from a given sequence. + * @brief Set the element value without copying. * - * @param s A sequence to copy elements from. + * @param p A new value to use. * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * This function will try to use the passed value directly instead + * of making a copy. */ void - openState (const openState_sequence& s); + reverseRate (::std::unique_ptr< reverseRate_type > p); //@} /** - * @name forwardTransition + * @name timeCourse * - * @brief Accessor and modifier functions for the %forwardTransition - * sequence element. + * @brief Accessor and modifier functions for the %timeCourse + * optional element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::ForwardTransition forwardTransition_type; + typedef ::neuroml2::HHTime timeCourse_type; /** - * @brief Element sequence container type. + * @brief Element optional container type. */ - typedef ::xsd::cxx::tree::sequence< forwardTransition_type > forwardTransition_sequence; + typedef ::xsd::cxx::tree::optional< timeCourse_type > timeCourse_optional; /** - * @brief Element iterator type. + * @brief Element traits type. */ - typedef forwardTransition_sequence::iterator forwardTransition_iterator; + typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; /** - * @brief Element constant iterator type. + * @brief Return a read-only (constant) reference to the element + * container. + * + * @return A constant reference to the optional container. */ - typedef forwardTransition_sequence::const_iterator forwardTransition_const_iterator; + const timeCourse_optional& + timeCourse () const; /** - * @brief Element traits type. + * @brief Return a read-write reference to the element container. + * + * @return A reference to the optional container. */ - typedef ::xsd::cxx::tree::traits< forwardTransition_type, char > forwardTransition_traits; + timeCourse_optional& + timeCourse (); /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Set the element value. * - * @return A constant reference to the sequence container. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. */ - const forwardTransition_sequence& - forwardTransition () const; + void + timeCourse (const timeCourse_type& x); /** - * @brief Return a read-write reference to the element sequence. + * @brief Set the element value. * - * @return A reference to the sequence container. + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. */ - forwardTransition_sequence& - forwardTransition (); + void + timeCourse (const timeCourse_optional& x); /** - * @brief Copy elements from a given sequence. + * @brief Set the element value without copying. * - * @param s A sequence to copy elements from. + * @param p A new value to use. * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * This function will try to use the passed value directly instead + * of making a copy. */ void - forwardTransition (const forwardTransition_sequence& s); + timeCourse (::std::unique_ptr< timeCourse_type > p); //@} /** - * @name reverseTransition + * @name steadyState * - * @brief Accessor and modifier functions for the %reverseTransition - * sequence element. + * @brief Accessor and modifier functions for the %steadyState + * optional element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::ReverseTransition reverseTransition_type; + typedef ::neuroml2::HHVariable steadyState_type; /** - * @brief Element sequence container type. + * @brief Element optional container type. */ - typedef ::xsd::cxx::tree::sequence< reverseTransition_type > reverseTransition_sequence; + typedef ::xsd::cxx::tree::optional< steadyState_type > steadyState_optional; /** - * @brief Element iterator type. + * @brief Element traits type. */ - typedef reverseTransition_sequence::iterator reverseTransition_iterator; + typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; /** - * @brief Element constant iterator type. + * @brief Return a read-only (constant) reference to the element + * container. + * + * @return A constant reference to the optional container. */ - typedef reverseTransition_sequence::const_iterator reverseTransition_const_iterator; + const steadyState_optional& + steadyState () const; /** - * @brief Element traits type. + * @brief Return a read-write reference to the element container. + * + * @return A reference to the optional container. */ - typedef ::xsd::cxx::tree::traits< reverseTransition_type, char > reverseTransition_traits; + steadyState_optional& + steadyState (); /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Set the element value. * - * @return A constant reference to the sequence container. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. */ - const reverseTransition_sequence& - reverseTransition () const; + void + steadyState (const steadyState_type& x); /** - * @brief Return a read-write reference to the element sequence. + * @brief Set the element value. * - * @return A reference to the sequence container. + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. */ - reverseTransition_sequence& - reverseTransition (); + void + steadyState (const steadyState_optional& x); /** - * @brief Copy elements from a given sequence. + * @brief Set the element value without copying. * - * @param s A sequence to copy elements from. + * @param p A new value to use. * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * This function will try to use the passed value directly instead + * of making a copy. */ void - reverseTransition (const reverseTransition_sequence& s); + steadyState (::std::unique_ptr< steadyState_type > p); //@} /** - * @name tauInfTransition + * @name subGate * - * @brief Accessor and modifier functions for the %tauInfTransition + * @brief Accessor and modifier functions for the %subGate * sequence element. */ //@{ @@ -17015,27 +20577,27 @@ namespace neuroml2 /** * @brief Element type. */ - typedef ::neuroml2::TauInfTransition tauInfTransition_type; + typedef ::neuroml2::GateFractionalSubgate subGate_type; /** * @brief Element sequence container type. */ - typedef ::xsd::cxx::tree::sequence< tauInfTransition_type > tauInfTransition_sequence; + typedef ::xsd::cxx::tree::sequence< subGate_type > subGate_sequence; /** * @brief Element iterator type. */ - typedef tauInfTransition_sequence::iterator tauInfTransition_iterator; + typedef subGate_sequence::iterator subGate_iterator; /** * @brief Element constant iterator type. */ - typedef tauInfTransition_sequence::const_iterator tauInfTransition_const_iterator; + typedef subGate_sequence::const_iterator subGate_const_iterator; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< tauInfTransition_type, char > tauInfTransition_traits; + typedef ::xsd::cxx::tree::traits< subGate_type, char > subGate_traits; /** * @brief Return a read-only (constant) reference to the element @@ -17043,16 +20605,16 @@ namespace neuroml2 * * @return A constant reference to the sequence container. */ - const tauInfTransition_sequence& - tauInfTransition () const; + const subGate_sequence& + subGate () const; /** * @brief Return a read-write reference to the element sequence. * * @return A reference to the sequence container. */ - tauInfTransition_sequence& - tauInfTransition (); + subGate_sequence& + subGate (); /** * @brief Copy elements from a given sequence. @@ -17064,7 +20626,7 @@ namespace neuroml2 * sequence and all old elements will be lost. */ void - tauInfTransition (const tauInfTransition_sequence& s); + subGate (const subGate_sequence& s); //@} @@ -17126,6 +20688,64 @@ namespace neuroml2 //@} + /** + * @name type + * + * @brief Accessor and modifier functions for the %type + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::gateTypes type_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const type_type& + type () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + type_type& + type (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + type (const type_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + type (::std::unique_ptr< type_type > p); + + //@} + /** * @name Constructors */ @@ -17135,8 +20755,9 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GateKS (const id_type&, - const instances_type&); + GateHHUndetermined (const id_type&, + const instances_type&, + const type_type&); /** * @brief Create an instance from a DOM element. @@ -17145,10 +20766,10 @@ namespace neuroml2 * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. - */ - GateKS (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + */ + GateHHUndetermined (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -17159,9 +20780,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateKS (const GateKS& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateHHUndetermined (const GateHHUndetermined& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -17174,7 +20795,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GateKS* + virtual GateHHUndetermined* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -17186,8 +20807,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateKS& - operator= (const GateKS& x); + GateHHUndetermined& + operator= (const GateHHUndetermined& x); //@} @@ -17195,7 +20816,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GateKS (); + ~GateHHUndetermined (); // Implementation. // @@ -17210,33 +20831,33 @@ namespace neuroml2 protected: notes_optional notes_; q10Settings_optional q10Settings_; - closedState_sequence closedState_; - openState_sequence openState_; - forwardTransition_sequence forwardTransition_; - reverseTransition_sequence reverseTransition_; - tauInfTransition_sequence tauInfTransition_; + forwardRate_optional forwardRate_; + reverseRate_optional reverseRate_; + timeCourse_optional timeCourse_; + steadyState_optional steadyState_; + subGate_sequence subGate_; ::xsd::cxx::tree::one< instances_type > instances_; + ::xsd::cxx::tree::one< type_type > type_; //@endcond }; bool - operator== (const GateKS&, const GateKS&); + operator== (const GateHHUndetermined&, const GateHHUndetermined&); bool - operator!= (const GateKS&, const GateKS&); + operator!= (const GateHHUndetermined&, const GateHHUndetermined&); /** - * @brief Class corresponding to the %GateHHUndetermined schema type. + * @brief Class corresponding to the %GateHHRates schema type. * - * Note all sub elements for gateHHrates, gateHHratesTau, gateFractional - * etc. allowed here. Which are valid should be constrained by what type - * is set + * Gate which follows the general Hodgkin Huxley formalism + * @param instances * * @nosubgrouping */ - class GateHHUndetermined: public ::neuroml2::Base + class GateHHRates: public ::neuroml2::Base { public: /** @@ -17395,7 +21016,7 @@ namespace neuroml2 * @name forwardRate * * @brief Accessor and modifier functions for the %forwardRate - * optional element. + * required element. */ //@{ @@ -17404,31 +21025,25 @@ namespace neuroml2 */ typedef ::neuroml2::HHRate forwardRate_type; - /** - * @brief Element optional container type. - */ - typedef ::xsd::cxx::tree::optional< forwardRate_type > forwardRate_optional; - /** * @brief Element traits type. */ typedef ::xsd::cxx::tree::traits< forwardRate_type, char > forwardRate_traits; /** - * @brief Return a read-only (constant) reference to the element - * container. + * @brief Return a read-only (constant) reference to the element. * - * @return A constant reference to the optional container. + * @return A constant reference to the element. */ - const forwardRate_optional& + const forwardRate_type& forwardRate () const; /** - * @brief Return a read-write reference to the element container. + * @brief Return a read-write reference to the element. * - * @return A reference to the optional container. + * @return A reference to the element. */ - forwardRate_optional& + forwardRate_type& forwardRate (); /** @@ -17442,25 +21057,13 @@ namespace neuroml2 void forwardRate (const forwardRate_type& x); - /** - * @brief Set the element value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. - */ - void - forwardRate (const forwardRate_optional& x); - /** * @brief Set the element value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void forwardRate (::std::unique_ptr< forwardRate_type > p); @@ -17471,7 +21074,7 @@ namespace neuroml2 * @name reverseRate * * @brief Accessor and modifier functions for the %reverseRate - * optional element. + * required element. */ //@{ @@ -17480,31 +21083,25 @@ namespace neuroml2 */ typedef ::neuroml2::HHRate reverseRate_type; - /** - * @brief Element optional container type. - */ - typedef ::xsd::cxx::tree::optional< reverseRate_type > reverseRate_optional; - /** * @brief Element traits type. */ typedef ::xsd::cxx::tree::traits< reverseRate_type, char > reverseRate_traits; /** - * @brief Return a read-only (constant) reference to the element - * container. + * @brief Return a read-only (constant) reference to the element. * - * @return A constant reference to the optional container. + * @return A constant reference to the element. */ - const reverseRate_optional& + const reverseRate_type& reverseRate () const; /** - * @brief Return a read-write reference to the element container. + * @brief Return a read-write reference to the element. * - * @return A reference to the optional container. + * @return A reference to the element. */ - reverseRate_optional& + reverseRate_type& reverseRate (); /** @@ -17519,34 +21116,204 @@ namespace neuroml2 reverseRate (const reverseRate_type& x); /** - * @brief Set the element value. + * @brief Set the element value without copying. * - * @param x An optional container with the new value to set. + * @param p A new value to use. * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. + * This function will try to use the passed value directly + * instead of making a copy. */ void - reverseRate (const reverseRate_optional& x); + reverseRate (::std::unique_ptr< reverseRate_type > p); + + //@} /** - * @brief Set the element value without copying. + * @name instances + * + * @brief Accessor and modifier functions for the %instances + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::PositiveInteger instances_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< instances_type, char > instances_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const instances_type& + instances () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + instances_type& + instances (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + instances (const instances_type& x); + + /** + * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - reverseRate (::std::unique_ptr< reverseRate_type > p); + instances (::std::unique_ptr< instances_type > p); //@} /** - * @name timeCourse + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + GateHHRates (const id_type&, + const forwardRate_type&, + const reverseRate_type&, + const instances_type&); + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes + * (::std::unique_ptr version). * - * @brief Accessor and modifier functions for the %timeCourse + * This constructor will try to use the passed values directly + * instead of making copies. + */ + GateHHRates (const id_type&, + ::std::unique_ptr< forwardRate_type >, + ::std::unique_ptr< reverseRate_type >, + const instances_type&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + GateHHRates (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + GateHHRates (const GateHHRates& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual GateHHRates* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + /** + * @brief Copy assignment operator. + * + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. + */ + GateHHRates& + operator= (const GateHHRates& x); + + //@} + + /** + * @brief Destructor. + */ + virtual + ~GateHHRates (); + + // Implementation. + // + + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + notes_optional notes_; + q10Settings_optional q10Settings_; + ::xsd::cxx::tree::one< forwardRate_type > forwardRate_; + ::xsd::cxx::tree::one< reverseRate_type > reverseRate_; + ::xsd::cxx::tree::one< instances_type > instances_; + + //@endcond + }; + + bool + operator== (const GateHHRates&, const GateHHRates&); + + bool + operator!= (const GateHHRates&, const GateHHRates&); + + + /** + * @brief Class corresponding to the %GateHHTauInf schema type. + * + * Gate which follows the general Hodgkin Huxley formalism + * @param instances + * + * @nosubgrouping + */ + class GateHHTauInf: public ::neuroml2::Base + { + public: + /** + * @name notes + * + * @brief Accessor and modifier functions for the %notes * optional element. */ //@{ @@ -17554,17 +21321,17 @@ namespace neuroml2 /** * @brief Element type. */ - typedef ::neuroml2::HHTime timeCourse_type; + typedef ::neuroml2::Notes notes_type; /** * @brief Element optional container type. */ - typedef ::xsd::cxx::tree::optional< timeCourse_type > timeCourse_optional; + typedef ::xsd::cxx::tree::optional< notes_type > notes_optional; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; + typedef ::xsd::cxx::tree::traits< notes_type, char > notes_traits; /** * @brief Return a read-only (constant) reference to the element @@ -17572,16 +21339,16 @@ namespace neuroml2 * * @return A constant reference to the optional container. */ - const timeCourse_optional& - timeCourse () const; + const notes_optional& + notes () const; /** * @brief Return a read-write reference to the element container. * * @return A reference to the optional container. */ - timeCourse_optional& - timeCourse (); + notes_optional& + notes (); /** * @brief Set the element value. @@ -17592,7 +21359,7 @@ namespace neuroml2 * the new value of the element. */ void - timeCourse (const timeCourse_type& x); + notes (const notes_type& x); /** * @brief Set the element value. @@ -17604,7 +21371,7 @@ namespace neuroml2 * Otherwise the element container is set the 'not present' state. */ void - timeCourse (const timeCourse_optional& x); + notes (const notes_optional& x); /** * @brief Set the element value without copying. @@ -17615,14 +21382,14 @@ namespace neuroml2 * of making a copy. */ void - timeCourse (::std::unique_ptr< timeCourse_type > p); + notes (::std::unique_ptr< notes_type > p); //@} /** - * @name steadyState + * @name q10Settings * - * @brief Accessor and modifier functions for the %steadyState + * @brief Accessor and modifier functions for the %q10Settings * optional element. */ //@{ @@ -17630,17 +21397,17 @@ namespace neuroml2 /** * @brief Element type. */ - typedef ::neuroml2::HHVariable steadyState_type; + typedef ::neuroml2::Q10Settings q10Settings_type; /** * @brief Element optional container type. */ - typedef ::xsd::cxx::tree::optional< steadyState_type > steadyState_optional; + typedef ::xsd::cxx::tree::optional< q10Settings_type > q10Settings_optional; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; + typedef ::xsd::cxx::tree::traits< q10Settings_type, char > q10Settings_traits; /** * @brief Return a read-only (constant) reference to the element @@ -17648,16 +21415,16 @@ namespace neuroml2 * * @return A constant reference to the optional container. */ - const steadyState_optional& - steadyState () const; + const q10Settings_optional& + q10Settings () const; /** * @brief Return a read-write reference to the element container. * * @return A reference to the optional container. */ - steadyState_optional& - steadyState (); + q10Settings_optional& + q10Settings (); /** * @brief Set the element value. @@ -17668,7 +21435,7 @@ namespace neuroml2 * the new value of the element. */ void - steadyState (const steadyState_type& x); + q10Settings (const q10Settings_type& x); /** * @brief Set the element value. @@ -17680,7 +21447,7 @@ namespace neuroml2 * Otherwise the element container is set the 'not present' state. */ void - steadyState (const steadyState_optional& x); + q10Settings (const q10Settings_optional& x); /** * @brief Set the element value without copying. @@ -17691,121 +21458,115 @@ namespace neuroml2 * of making a copy. */ void - steadyState (::std::unique_ptr< steadyState_type > p); + q10Settings (::std::unique_ptr< q10Settings_type > p); //@} /** - * @name subGate + * @name timeCourse * - * @brief Accessor and modifier functions for the %subGate - * sequence element. + * @brief Accessor and modifier functions for the %timeCourse + * required element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::GateFractionalSubgate subGate_type; - - /** - * @brief Element sequence container type. - */ - typedef ::xsd::cxx::tree::sequence< subGate_type > subGate_sequence; - - /** - * @brief Element iterator type. - */ - typedef subGate_sequence::iterator subGate_iterator; + typedef ::neuroml2::HHTime timeCourse_type; /** - * @brief Element constant iterator type. + * @brief Element traits type. */ - typedef subGate_sequence::const_iterator subGate_const_iterator; + typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; /** - * @brief Element traits type. + * @brief Return a read-only (constant) reference to the element. + * + * @return A constant reference to the element. */ - typedef ::xsd::cxx::tree::traits< subGate_type, char > subGate_traits; + const timeCourse_type& + timeCourse () const; /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Return a read-write reference to the element. * - * @return A constant reference to the sequence container. + * @return A reference to the element. */ - const subGate_sequence& - subGate () const; + timeCourse_type& + timeCourse (); /** - * @brief Return a read-write reference to the element sequence. + * @brief Set the element value. * - * @return A reference to the sequence container. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. */ - subGate_sequence& - subGate (); + void + timeCourse (const timeCourse_type& x); /** - * @brief Copy elements from a given sequence. + * @brief Set the element value without copying. * - * @param s A sequence to copy elements from. + * @param p A new value to use. * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * This function will try to use the passed value directly + * instead of making a copy. */ void - subGate (const subGate_sequence& s); + timeCourse (::std::unique_ptr< timeCourse_type > p); //@} /** - * @name instances + * @name steadyState * - * @brief Accessor and modifier functions for the %instances - * required attribute. + * @brief Accessor and modifier functions for the %steadyState + * required element. */ //@{ /** - * @brief Attribute type. + * @brief Element type. */ - typedef ::neuroml2::PositiveInteger instances_type; + typedef ::neuroml2::HHVariable steadyState_type; /** - * @brief Attribute traits type. + * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< instances_type, char > instances_traits; + typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Return a read-only (constant) reference to the element. * - * @return A constant reference to the attribute. + * @return A constant reference to the element. */ - const instances_type& - instances () const; + const steadyState_type& + steadyState () const; /** - * @brief Return a read-write reference to the attribute. + * @brief Return a read-write reference to the element. * - * @return A reference to the attribute. + * @return A reference to the element. */ - instances_type& - instances (); + steadyState_type& + steadyState (); /** - * @brief Set the attribute value. + * @brief Set the element value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * the new value of the element. */ void - instances (const instances_type& x); + steadyState (const steadyState_type& x); /** - * @brief Set the attribute value without copying. + * @brief Set the element value without copying. * * @param p A new value to use. * @@ -17813,14 +21574,14 @@ namespace neuroml2 * instead of making a copy. */ void - instances (::std::unique_ptr< instances_type > p); + steadyState (::std::unique_ptr< steadyState_type > p); //@} /** - * @name type + * @name instances * - * @brief Accessor and modifier functions for the %type + * @brief Accessor and modifier functions for the %instances * required attribute. */ //@{ @@ -17828,28 +21589,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::gateTypes type_type; + typedef ::neuroml2::PositiveInteger instances_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; + typedef ::xsd::cxx::tree::traits< instances_type, char > instances_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const type_type& - type () const; + const instances_type& + instances () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - type_type& - type (); + instances_type& + instances (); /** * @brief Set the attribute value. @@ -17860,7 +21621,7 @@ namespace neuroml2 * the new value of the attribute. */ void - type (const type_type& x); + instances (const instances_type& x); /** * @brief Set the attribute value without copying. @@ -17871,7 +21632,7 @@ namespace neuroml2 * instead of making a copy. */ void - type (::std::unique_ptr< type_type > p); + instances (::std::unique_ptr< instances_type > p); //@} @@ -17884,9 +21645,23 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GateHHUndetermined (const id_type&, - const instances_type&, - const type_type&); + GateHHTauInf (const id_type&, + const timeCourse_type&, + const steadyState_type&, + const instances_type&); + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes + * (::std::unique_ptr version). + * + * This constructor will try to use the passed values directly + * instead of making copies. + */ + GateHHTauInf (const id_type&, + ::std::unique_ptr< timeCourse_type >, + ::std::unique_ptr< steadyState_type >, + const instances_type&); /** * @brief Create an instance from a DOM element. @@ -17896,9 +21671,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - GateHHUndetermined (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateHHTauInf (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -17909,9 +21684,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHUndetermined (const GateHHUndetermined& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateHHTauInf (const GateHHTauInf& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -17924,7 +21699,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GateHHUndetermined* + virtual GateHHTauInf* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -17936,8 +21711,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHUndetermined& - operator= (const GateHHUndetermined& x); + GateHHTauInf& + operator= (const GateHHTauInf& x); //@} @@ -17945,7 +21720,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GateHHUndetermined (); + ~GateHHTauInf (); // Implementation. // @@ -17960,33 +21735,29 @@ namespace neuroml2 protected: notes_optional notes_; q10Settings_optional q10Settings_; - forwardRate_optional forwardRate_; - reverseRate_optional reverseRate_; - timeCourse_optional timeCourse_; - steadyState_optional steadyState_; - subGate_sequence subGate_; + ::xsd::cxx::tree::one< timeCourse_type > timeCourse_; + ::xsd::cxx::tree::one< steadyState_type > steadyState_; ::xsd::cxx::tree::one< instances_type > instances_; - ::xsd::cxx::tree::one< type_type > type_; //@endcond }; bool - operator== (const GateHHUndetermined&, const GateHHUndetermined&); + operator== (const GateHHTauInf&, const GateHHTauInf&); bool - operator!= (const GateHHUndetermined&, const GateHHUndetermined&); + operator!= (const GateHHTauInf&, const GateHHTauInf&); /** - * @brief Class corresponding to the %GateHHRates schema type. + * @brief Class corresponding to the %GateHHRatesTauInf schema type. * * Gate which follows the general Hodgkin Huxley formalism * @param instances * * @nosubgrouping */ - class GateHHRates: public ::neuroml2::Base + class GateHHRatesTauInf: public ::neuroml2::Base { public: /** @@ -18257,6 +22028,122 @@ namespace neuroml2 //@} + /** + * @name timeCourse + * + * @brief Accessor and modifier functions for the %timeCourse + * required element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::HHTime timeCourse_type; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; + + /** + * @brief Return a read-only (constant) reference to the element. + * + * @return A constant reference to the element. + */ + const timeCourse_type& + timeCourse () const; + + /** + * @brief Return a read-write reference to the element. + * + * @return A reference to the element. + */ + timeCourse_type& + timeCourse (); + + /** + * @brief Set the element value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. + */ + void + timeCourse (const timeCourse_type& x); + + /** + * @brief Set the element value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + timeCourse (::std::unique_ptr< timeCourse_type > p); + + //@} + + /** + * @name steadyState + * + * @brief Accessor and modifier functions for the %steadyState + * required element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::HHVariable steadyState_type; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; + + /** + * @brief Return a read-only (constant) reference to the element. + * + * @return A constant reference to the element. + */ + const steadyState_type& + steadyState () const; + + /** + * @brief Return a read-write reference to the element. + * + * @return A reference to the element. + */ + steadyState_type& + steadyState (); + + /** + * @brief Set the element value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. + */ + void + steadyState (const steadyState_type& x); + + /** + * @brief Set the element value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + steadyState (::std::unique_ptr< steadyState_type > p); + + //@} + /** * @name instances * @@ -18324,10 +22211,12 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GateHHRates (const id_type&, - const forwardRate_type&, - const reverseRate_type&, - const instances_type&); + GateHHRatesTauInf (const id_type&, + const forwardRate_type&, + const reverseRate_type&, + const timeCourse_type&, + const steadyState_type&, + const instances_type&); /** * @brief Create an instance from the ultimate base and @@ -18337,10 +22226,12 @@ namespace neuroml2 * This constructor will try to use the passed values directly * instead of making copies. */ - GateHHRates (const id_type&, - ::std::unique_ptr< forwardRate_type >, - ::std::unique_ptr< reverseRate_type >, - const instances_type&); + GateHHRatesTauInf (const id_type&, + ::std::unique_ptr< forwardRate_type >, + ::std::unique_ptr< reverseRate_type >, + ::std::unique_ptr< timeCourse_type >, + ::std::unique_ptr< steadyState_type >, + const instances_type&); /** * @brief Create an instance from a DOM element. @@ -18350,9 +22241,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - GateHHRates (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateHHRatesTauInf (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -18363,9 +22254,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHRates (const GateHHRates& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateHHRatesTauInf (const GateHHRatesTauInf& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -18378,7 +22269,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GateHHRates* + virtual GateHHRatesTauInf* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -18390,8 +22281,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHRates& - operator= (const GateHHRates& x); + GateHHRatesTauInf& + operator= (const GateHHRatesTauInf& x); //@} @@ -18399,7 +22290,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GateHHRates (); + ~GateHHRatesTauInf (); // Implementation. // @@ -18416,27 +22307,29 @@ namespace neuroml2 q10Settings_optional q10Settings_; ::xsd::cxx::tree::one< forwardRate_type > forwardRate_; ::xsd::cxx::tree::one< reverseRate_type > reverseRate_; + ::xsd::cxx::tree::one< timeCourse_type > timeCourse_; + ::xsd::cxx::tree::one< steadyState_type > steadyState_; ::xsd::cxx::tree::one< instances_type > instances_; //@endcond }; bool - operator== (const GateHHRates&, const GateHHRates&); + operator== (const GateHHRatesTauInf&, const GateHHRatesTauInf&); bool - operator!= (const GateHHRates&, const GateHHRates&); + operator!= (const GateHHRatesTauInf&, const GateHHRatesTauInf&); /** - * @brief Class corresponding to the %GateHHTauInf schema type. + * @brief Class corresponding to the %GateHHRatesTau schema type. * * Gate which follows the general Hodgkin Huxley formalism * @param instances * * @nosubgrouping */ - class GateHHTauInf: public ::neuroml2::Base + class GateHHRatesTau: public ::neuroml2::Base { public: /** @@ -18592,9 +22485,9 @@ namespace neuroml2 //@} /** - * @name timeCourse + * @name forwardRate * - * @brief Accessor and modifier functions for the %timeCourse + * @brief Accessor and modifier functions for the %forwardRate * required element. */ //@{ @@ -18602,28 +22495,28 @@ namespace neuroml2 /** * @brief Element type. */ - typedef ::neuroml2::HHTime timeCourse_type; + typedef ::neuroml2::HHRate forwardRate_type; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; + typedef ::xsd::cxx::tree::traits< forwardRate_type, char > forwardRate_traits; /** * @brief Return a read-only (constant) reference to the element. * * @return A constant reference to the element. */ - const timeCourse_type& - timeCourse () const; + const forwardRate_type& + forwardRate () const; /** * @brief Return a read-write reference to the element. * * @return A reference to the element. */ - timeCourse_type& - timeCourse (); + forwardRate_type& + forwardRate (); /** * @brief Set the element value. @@ -18634,7 +22527,7 @@ namespace neuroml2 * the new value of the element. */ void - timeCourse (const timeCourse_type& x); + forwardRate (const forwardRate_type& x); /** * @brief Set the element value without copying. @@ -18645,14 +22538,14 @@ namespace neuroml2 * instead of making a copy. */ void - timeCourse (::std::unique_ptr< timeCourse_type > p); + forwardRate (::std::unique_ptr< forwardRate_type > p); //@} /** - * @name steadyState + * @name reverseRate * - * @brief Accessor and modifier functions for the %steadyState + * @brief Accessor and modifier functions for the %reverseRate * required element. */ //@{ @@ -18660,28 +22553,28 @@ namespace neuroml2 /** * @brief Element type. */ - typedef ::neuroml2::HHVariable steadyState_type; + typedef ::neuroml2::HHRate reverseRate_type; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; + typedef ::xsd::cxx::tree::traits< reverseRate_type, char > reverseRate_traits; /** * @brief Return a read-only (constant) reference to the element. * * @return A constant reference to the element. */ - const steadyState_type& - steadyState () const; + const reverseRate_type& + reverseRate () const; /** * @brief Return a read-write reference to the element. * * @return A reference to the element. */ - steadyState_type& - steadyState (); + reverseRate_type& + reverseRate (); /** * @brief Set the element value. @@ -18692,7 +22585,7 @@ namespace neuroml2 * the new value of the element. */ void - steadyState (const steadyState_type& x); + reverseRate (const reverseRate_type& x); /** * @brief Set the element value without copying. @@ -18703,7 +22596,65 @@ namespace neuroml2 * instead of making a copy. */ void - steadyState (::std::unique_ptr< steadyState_type > p); + reverseRate (::std::unique_ptr< reverseRate_type > p); + + //@} + + /** + * @name timeCourse + * + * @brief Accessor and modifier functions for the %timeCourse + * required element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::HHTime timeCourse_type; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; + + /** + * @brief Return a read-only (constant) reference to the element. + * + * @return A constant reference to the element. + */ + const timeCourse_type& + timeCourse () const; + + /** + * @brief Return a read-write reference to the element. + * + * @return A reference to the element. + */ + timeCourse_type& + timeCourse (); + + /** + * @brief Set the element value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the element. + */ + void + timeCourse (const timeCourse_type& x); + + /** + * @brief Set the element value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + timeCourse (::std::unique_ptr< timeCourse_type > p); //@} @@ -18774,10 +22725,11 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GateHHTauInf (const id_type&, - const timeCourse_type&, - const steadyState_type&, - const instances_type&); + GateHHRatesTau (const id_type&, + const forwardRate_type&, + const reverseRate_type&, + const timeCourse_type&, + const instances_type&); /** * @brief Create an instance from the ultimate base and @@ -18787,10 +22739,11 @@ namespace neuroml2 * This constructor will try to use the passed values directly * instead of making copies. */ - GateHHTauInf (const id_type&, - ::std::unique_ptr< timeCourse_type >, - ::std::unique_ptr< steadyState_type >, - const instances_type&); + GateHHRatesTau (const id_type&, + ::std::unique_ptr< forwardRate_type >, + ::std::unique_ptr< reverseRate_type >, + ::std::unique_ptr< timeCourse_type >, + const instances_type&); /** * @brief Create an instance from a DOM element. @@ -18800,9 +22753,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - GateHHTauInf (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateHHRatesTau (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -18813,9 +22766,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHTauInf (const GateHHTauInf& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateHHRatesTau (const GateHHRatesTau& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -18828,7 +22781,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GateHHTauInf* + virtual GateHHRatesTau* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -18840,8 +22793,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHTauInf& - operator= (const GateHHTauInf& x); + GateHHRatesTau& + operator= (const GateHHRatesTau& x); //@} @@ -18849,7 +22802,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GateHHTauInf (); + ~GateHHRatesTau (); // Implementation. // @@ -18864,29 +22817,30 @@ namespace neuroml2 protected: notes_optional notes_; q10Settings_optional q10Settings_; + ::xsd::cxx::tree::one< forwardRate_type > forwardRate_; + ::xsd::cxx::tree::one< reverseRate_type > reverseRate_; ::xsd::cxx::tree::one< timeCourse_type > timeCourse_; - ::xsd::cxx::tree::one< steadyState_type > steadyState_; ::xsd::cxx::tree::one< instances_type > instances_; //@endcond }; bool - operator== (const GateHHTauInf&, const GateHHTauInf&); + operator== (const GateHHRatesTau&, const GateHHRatesTau&); bool - operator!= (const GateHHTauInf&, const GateHHTauInf&); + operator!= (const GateHHRatesTau&, const GateHHRatesTau&); /** - * @brief Class corresponding to the %GateHHRatesTauInf schema type. + * @brief Class corresponding to the %GateHHRatesInf schema type. * * Gate which follows the general Hodgkin Huxley formalism * @param instances * * @nosubgrouping */ - class GateHHRatesTauInf: public ::neuroml2::Base + class GateHHRatesInf: public ::neuroml2::Base { public: /** @@ -19157,64 +23111,6 @@ namespace neuroml2 //@} - /** - * @name timeCourse - * - * @brief Accessor and modifier functions for the %timeCourse - * required element. - */ - //@{ - - /** - * @brief Element type. - */ - typedef ::neuroml2::HHTime timeCourse_type; - - /** - * @brief Element traits type. - */ - typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; - - /** - * @brief Return a read-only (constant) reference to the element. - * - * @return A constant reference to the element. - */ - const timeCourse_type& - timeCourse () const; - - /** - * @brief Return a read-write reference to the element. - * - * @return A reference to the element. - */ - timeCourse_type& - timeCourse (); - - /** - * @brief Set the element value. - * - * @param x A new value to set. - * - * This function makes a copy of its argument and sets it as - * the new value of the element. - */ - void - timeCourse (const timeCourse_type& x); - - /** - * @brief Set the element value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. - */ - void - timeCourse (::std::unique_ptr< timeCourse_type > p); - - //@} - /** * @name steadyState * @@ -19340,12 +23236,11 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GateHHRatesTauInf (const id_type&, - const forwardRate_type&, - const reverseRate_type&, - const timeCourse_type&, - const steadyState_type&, - const instances_type&); + GateHHRatesInf (const id_type&, + const forwardRate_type&, + const reverseRate_type&, + const steadyState_type&, + const instances_type&); /** * @brief Create an instance from the ultimate base and @@ -19355,12 +23250,11 @@ namespace neuroml2 * This constructor will try to use the passed values directly * instead of making copies. */ - GateHHRatesTauInf (const id_type&, - ::std::unique_ptr< forwardRate_type >, - ::std::unique_ptr< reverseRate_type >, - ::std::unique_ptr< timeCourse_type >, - ::std::unique_ptr< steadyState_type >, - const instances_type&); + GateHHRatesInf (const id_type&, + ::std::unique_ptr< forwardRate_type >, + ::std::unique_ptr< reverseRate_type >, + ::std::unique_ptr< steadyState_type >, + const instances_type&); /** * @brief Create an instance from a DOM element. @@ -19370,9 +23264,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - GateHHRatesTauInf (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateHHRatesInf (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -19383,9 +23277,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHRatesTauInf (const GateHHRatesTauInf& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateHHRatesInf (const GateHHRatesInf& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -19398,7 +23292,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GateHHRatesTauInf* + virtual GateHHRatesInf* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -19410,8 +23304,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHRatesTauInf& - operator= (const GateHHRatesTauInf& x); + GateHHRatesInf& + operator= (const GateHHRatesInf& x); //@} @@ -19419,7 +23313,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GateHHRatesTauInf (); + ~GateHHRatesInf (); // Implementation. // @@ -19436,7 +23330,6 @@ namespace neuroml2 q10Settings_optional q10Settings_; ::xsd::cxx::tree::one< forwardRate_type > forwardRate_; ::xsd::cxx::tree::one< reverseRate_type > reverseRate_; - ::xsd::cxx::tree::one< timeCourse_type > timeCourse_; ::xsd::cxx::tree::one< steadyState_type > steadyState_; ::xsd::cxx::tree::one< instances_type > instances_; @@ -19444,21 +23337,22 @@ namespace neuroml2 }; bool - operator== (const GateHHRatesTauInf&, const GateHHRatesTauInf&); + operator== (const GateHHRatesInf&, const GateHHRatesInf&); bool - operator!= (const GateHHRatesTauInf&, const GateHHRatesTauInf&); + operator!= (const GateHHRatesInf&, const GateHHRatesInf&); /** - * @brief Class corresponding to the %GateHHRatesTau schema type. + * @brief Class corresponding to the %GateHHInstantaneous schema type. * - * Gate which follows the general Hodgkin Huxley formalism + * Gate which follows the general Hodgkin Huxley formalism but is + * instantaneous, so tau = 0 and gate follows exactly inf value * @param instances * * @nosubgrouping */ - class GateHHRatesTau: public ::neuroml2::Base + class GateHHInstantaneous: public ::neuroml2::Base { public: /** @@ -19538,44 +23432,38 @@ namespace neuroml2 //@} /** - * @name q10Settings + * @name steadyState * - * @brief Accessor and modifier functions for the %q10Settings - * optional element. + * @brief Accessor and modifier functions for the %steadyState + * required element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::Q10Settings q10Settings_type; - - /** - * @brief Element optional container type. - */ - typedef ::xsd::cxx::tree::optional< q10Settings_type > q10Settings_optional; + typedef ::neuroml2::HHVariable steadyState_type; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< q10Settings_type, char > q10Settings_traits; + typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; /** - * @brief Return a read-only (constant) reference to the element - * container. + * @brief Return a read-only (constant) reference to the element. * - * @return A constant reference to the optional container. + * @return A constant reference to the element. */ - const q10Settings_optional& - q10Settings () const; + const steadyState_type& + steadyState () const; /** - * @brief Return a read-write reference to the element container. + * @brief Return a read-write reference to the element. * - * @return A reference to the optional container. + * @return A reference to the element. */ - q10Settings_optional& - q10Settings (); + steadyState_type& + steadyState (); /** * @brief Set the element value. @@ -19586,80 +23474,68 @@ namespace neuroml2 * the new value of the element. */ void - q10Settings (const q10Settings_type& x); - - /** - * @brief Set the element value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. - */ - void - q10Settings (const q10Settings_optional& x); + steadyState (const steadyState_type& x); /** * @brief Set the element value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - q10Settings (::std::unique_ptr< q10Settings_type > p); + steadyState (::std::unique_ptr< steadyState_type > p); //@} /** - * @name forwardRate + * @name instances * - * @brief Accessor and modifier functions for the %forwardRate - * required element. + * @brief Accessor and modifier functions for the %instances + * required attribute. */ //@{ /** - * @brief Element type. + * @brief Attribute type. */ - typedef ::neuroml2::HHRate forwardRate_type; + typedef ::neuroml2::PositiveInteger instances_type; /** - * @brief Element traits type. + * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< forwardRate_type, char > forwardRate_traits; + typedef ::xsd::cxx::tree::traits< instances_type, char > instances_traits; /** - * @brief Return a read-only (constant) reference to the element. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the element. + * @return A constant reference to the attribute. */ - const forwardRate_type& - forwardRate () const; + const instances_type& + instances () const; /** - * @brief Return a read-write reference to the element. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the element. + * @return A reference to the attribute. */ - forwardRate_type& - forwardRate (); + instances_type& + instances (); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the element. + * the new value of the attribute. */ void - forwardRate (const forwardRate_type& x); + instances (const instances_type& x); /** - * @brief Set the element value without copying. + * @brief Set the attribute value without copying. * * @param p A new value to use. * @@ -19667,43 +23543,169 @@ namespace neuroml2 * instead of making a copy. */ void - forwardRate (::std::unique_ptr< forwardRate_type > p); + instances (::std::unique_ptr< instances_type > p); //@} /** - * @name reverseRate + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + GateHHInstantaneous (const id_type&, + const steadyState_type&, + const instances_type&); + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes + * (::std::unique_ptr version). * - * @brief Accessor and modifier functions for the %reverseRate - * required element. + * This constructor will try to use the passed values directly + * instead of making copies. + */ + GateHHInstantaneous (const id_type&, + ::std::unique_ptr< steadyState_type >, + const instances_type&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. + */ + GateHHInstantaneous (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. + */ + GateHHInstantaneous (const GateHHInstantaneous& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); + + /** + * @brief Copy the instance polymorphically. + * + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. + */ + virtual GateHHInstantaneous* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + /** + * @brief Copy assignment operator. + * + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. + */ + GateHHInstantaneous& + operator= (const GateHHInstantaneous& x); + + //@} + + /** + * @brief Destructor. + */ + virtual + ~GateHHInstantaneous (); + + // Implementation. + // + + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + notes_optional notes_; + ::xsd::cxx::tree::one< steadyState_type > steadyState_; + ::xsd::cxx::tree::one< instances_type > instances_; + + //@endcond + }; + + bool + operator== (const GateHHInstantaneous&, const GateHHInstantaneous&); + + bool + operator!= (const GateHHInstantaneous&, const GateHHInstantaneous&); + + + /** + * @brief Class corresponding to the %GateFractional schema type. + * + * Gate composed of subgates contributing with fractional conductance + * @param instances + * + * @nosubgrouping + */ + class GateFractional: public ::neuroml2::Base + { + public: + /** + * @name notes + * + * @brief Accessor and modifier functions for the %notes + * optional element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::HHRate reverseRate_type; + typedef ::neuroml2::Notes notes_type; + + /** + * @brief Element optional container type. + */ + typedef ::xsd::cxx::tree::optional< notes_type > notes_optional; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< reverseRate_type, char > reverseRate_traits; + typedef ::xsd::cxx::tree::traits< notes_type, char > notes_traits; /** - * @brief Return a read-only (constant) reference to the element. + * @brief Return a read-only (constant) reference to the element + * container. * - * @return A constant reference to the element. + * @return A constant reference to the optional container. */ - const reverseRate_type& - reverseRate () const; + const notes_optional& + notes () const; /** - * @brief Return a read-write reference to the element. + * @brief Return a read-write reference to the element container. * - * @return A reference to the element. + * @return A reference to the optional container. */ - reverseRate_type& - reverseRate (); + notes_optional& + notes (); /** * @brief Set the element value. @@ -19714,54 +23716,72 @@ namespace neuroml2 * the new value of the element. */ void - reverseRate (const reverseRate_type& x); + notes (const notes_type& x); + + /** + * @brief Set the element value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. + */ + void + notes (const notes_optional& x); /** * @brief Set the element value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - reverseRate (::std::unique_ptr< reverseRate_type > p); + notes (::std::unique_ptr< notes_type > p); //@} /** - * @name timeCourse + * @name q10Settings * - * @brief Accessor and modifier functions for the %timeCourse - * required element. + * @brief Accessor and modifier functions for the %q10Settings + * optional element. */ //@{ /** * @brief Element type. */ - typedef ::neuroml2::HHTime timeCourse_type; + typedef ::neuroml2::Q10Settings q10Settings_type; + + /** + * @brief Element optional container type. + */ + typedef ::xsd::cxx::tree::optional< q10Settings_type > q10Settings_optional; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; + typedef ::xsd::cxx::tree::traits< q10Settings_type, char > q10Settings_traits; /** - * @brief Return a read-only (constant) reference to the element. + * @brief Return a read-only (constant) reference to the element + * container. * - * @return A constant reference to the element. + * @return A constant reference to the optional container. */ - const timeCourse_type& - timeCourse () const; + const q10Settings_optional& + q10Settings () const; /** - * @brief Return a read-write reference to the element. + * @brief Return a read-write reference to the element container. * - * @return A reference to the element. + * @return A reference to the optional container. */ - timeCourse_type& - timeCourse (); + q10Settings_optional& + q10Settings (); /** * @brief Set the element value. @@ -19772,18 +23792,94 @@ namespace neuroml2 * the new value of the element. */ void - timeCourse (const timeCourse_type& x); + q10Settings (const q10Settings_type& x); + + /** + * @brief Set the element value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. + */ + void + q10Settings (const q10Settings_optional& x); /** * @brief Set the element value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - timeCourse (::std::unique_ptr< timeCourse_type > p); + q10Settings (::std::unique_ptr< q10Settings_type > p); + + //@} + + /** + * @name subGate + * + * @brief Accessor and modifier functions for the %subGate + * sequence element. + */ + //@{ + + /** + * @brief Element type. + */ + typedef ::neuroml2::GateFractionalSubgate subGate_type; + + /** + * @brief Element sequence container type. + */ + typedef ::xsd::cxx::tree::sequence< subGate_type > subGate_sequence; + + /** + * @brief Element iterator type. + */ + typedef subGate_sequence::iterator subGate_iterator; + + /** + * @brief Element constant iterator type. + */ + typedef subGate_sequence::const_iterator subGate_const_iterator; + + /** + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< subGate_type, char > subGate_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * sequence. + * + * @return A constant reference to the sequence container. + */ + const subGate_sequence& + subGate () const; + + /** + * @brief Return a read-write reference to the element sequence. + * + * @return A reference to the sequence container. + */ + subGate_sequence& + subGate (); + + /** + * @brief Copy elements from a given sequence. + * + * @param s A sequence to copy elements from. + * + * For each element in @a s this function makes a copy and adds it + * to the sequence. Note that this operation completely changes the + * sequence and all old elements will be lost. + */ + void + subGate (const subGate_sequence& s); //@} @@ -19854,24 +23950,7 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GateHHRatesTau (const id_type&, - const forwardRate_type&, - const reverseRate_type&, - const timeCourse_type&, - const instances_type&); - - /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes - * (::std::unique_ptr version). - * - * This constructor will try to use the passed values directly - * instead of making copies. - */ - GateHHRatesTau (const id_type&, - ::std::unique_ptr< forwardRate_type >, - ::std::unique_ptr< reverseRate_type >, - ::std::unique_ptr< timeCourse_type >, + GateFractional (const id_type&, const instances_type&); /** @@ -19882,7 +23961,7 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - GateHHRatesTau (const ::xercesc::DOMElement& e, + GateFractional (const ::xercesc::DOMElement& e, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -19895,7 +23974,7 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHRatesTau (const GateHHRatesTau& x, + GateFractional (const GateFractional& x, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -19910,7 +23989,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GateHHRatesTau* + virtual GateFractional* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -19922,8 +24001,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHRatesTau& - operator= (const GateHHRatesTau& x); + GateFractional& + operator= (const GateFractional& x); //@} @@ -19931,7 +24010,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GateHHRatesTau (); + ~GateFractional (); // Implementation. // @@ -19946,30 +24025,25 @@ namespace neuroml2 protected: notes_optional notes_; q10Settings_optional q10Settings_; - ::xsd::cxx::tree::one< forwardRate_type > forwardRate_; - ::xsd::cxx::tree::one< reverseRate_type > reverseRate_; - ::xsd::cxx::tree::one< timeCourse_type > timeCourse_; + subGate_sequence subGate_; ::xsd::cxx::tree::one< instances_type > instances_; //@endcond }; bool - operator== (const GateHHRatesTau&, const GateHHRatesTau&); + operator== (const GateFractional&, const GateFractional&); bool - operator!= (const GateHHRatesTau&, const GateHHRatesTau&); + operator!= (const GateFractional&, const GateFractional&); /** - * @brief Class corresponding to the %GateHHRatesInf schema type. - * - * Gate which follows the general Hodgkin Huxley formalism - * @param instances + * @brief Class corresponding to the %GateFractionalSubgate schema type. * * @nosubgrouping */ - class GateHHRatesInf: public ::neuroml2::Base + class GateFractionalSubgate: public ::neuroml2::Base { public: /** @@ -20125,67 +24199,9 @@ namespace neuroml2 //@} /** - * @name forwardRate - * - * @brief Accessor and modifier functions for the %forwardRate - * required element. - */ - //@{ - - /** - * @brief Element type. - */ - typedef ::neuroml2::HHRate forwardRate_type; - - /** - * @brief Element traits type. - */ - typedef ::xsd::cxx::tree::traits< forwardRate_type, char > forwardRate_traits; - - /** - * @brief Return a read-only (constant) reference to the element. - * - * @return A constant reference to the element. - */ - const forwardRate_type& - forwardRate () const; - - /** - * @brief Return a read-write reference to the element. - * - * @return A reference to the element. - */ - forwardRate_type& - forwardRate (); - - /** - * @brief Set the element value. - * - * @param x A new value to set. - * - * This function makes a copy of its argument and sets it as - * the new value of the element. - */ - void - forwardRate (const forwardRate_type& x); - - /** - * @brief Set the element value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. - */ - void - forwardRate (::std::unique_ptr< forwardRate_type > p); - - //@} - - /** - * @name reverseRate + * @name steadyState * - * @brief Accessor and modifier functions for the %reverseRate + * @brief Accessor and modifier functions for the %steadyState * required element. */ //@{ @@ -20193,28 +24209,28 @@ namespace neuroml2 /** * @brief Element type. */ - typedef ::neuroml2::HHRate reverseRate_type; + typedef ::neuroml2::HHVariable steadyState_type; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< reverseRate_type, char > reverseRate_traits; + typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; /** * @brief Return a read-only (constant) reference to the element. * * @return A constant reference to the element. */ - const reverseRate_type& - reverseRate () const; + const steadyState_type& + steadyState () const; /** * @brief Return a read-write reference to the element. * * @return A reference to the element. */ - reverseRate_type& - reverseRate (); + steadyState_type& + steadyState (); /** * @brief Set the element value. @@ -20225,7 +24241,7 @@ namespace neuroml2 * the new value of the element. */ void - reverseRate (const reverseRate_type& x); + steadyState (const steadyState_type& x); /** * @brief Set the element value without copying. @@ -20236,14 +24252,14 @@ namespace neuroml2 * instead of making a copy. */ void - reverseRate (::std::unique_ptr< reverseRate_type > p); + steadyState (::std::unique_ptr< steadyState_type > p); //@} /** - * @name steadyState + * @name timeCourse * - * @brief Accessor and modifier functions for the %steadyState + * @brief Accessor and modifier functions for the %timeCourse * required element. */ //@{ @@ -20251,28 +24267,28 @@ namespace neuroml2 /** * @brief Element type. */ - typedef ::neuroml2::HHVariable steadyState_type; + typedef ::neuroml2::HHTime timeCourse_type; /** * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; + typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; /** * @brief Return a read-only (constant) reference to the element. * * @return A constant reference to the element. */ - const steadyState_type& - steadyState () const; + const timeCourse_type& + timeCourse () const; /** * @brief Return a read-write reference to the element. * * @return A reference to the element. */ - steadyState_type& - steadyState (); + timeCourse_type& + timeCourse (); /** * @brief Set the element value. @@ -20283,7 +24299,7 @@ namespace neuroml2 * the new value of the element. */ void - steadyState (const steadyState_type& x); + timeCourse (const timeCourse_type& x); /** * @brief Set the element value without copying. @@ -20294,14 +24310,14 @@ namespace neuroml2 * instead of making a copy. */ void - steadyState (::std::unique_ptr< steadyState_type > p); + timeCourse (::std::unique_ptr< timeCourse_type > p); //@} /** - * @name instances + * @name fractionalConductance * - * @brief Accessor and modifier functions for the %instances + * @brief Accessor and modifier functions for the %fractionalConductance * required attribute. */ //@{ @@ -20309,28 +24325,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::PositiveInteger instances_type; + typedef ::neuroml2::Nml2Quantity_none fractionalConductance_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< instances_type, char > instances_traits; + typedef ::xsd::cxx::tree::traits< fractionalConductance_type, char > fractionalConductance_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const instances_type& - instances () const; + const fractionalConductance_type& + fractionalConductance () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - instances_type& - instances (); + fractionalConductance_type& + fractionalConductance (); /** * @brief Set the attribute value. @@ -20341,7 +24357,7 @@ namespace neuroml2 * the new value of the attribute. */ void - instances (const instances_type& x); + fractionalConductance (const fractionalConductance_type& x); /** * @brief Set the attribute value without copying. @@ -20352,7 +24368,7 @@ namespace neuroml2 * instead of making a copy. */ void - instances (::std::unique_ptr< instances_type > p); + fractionalConductance (::std::unique_ptr< fractionalConductance_type > p); //@} @@ -20365,11 +24381,10 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GateHHRatesInf (const id_type&, - const forwardRate_type&, - const reverseRate_type&, - const steadyState_type&, - const instances_type&); + GateFractionalSubgate (const id_type&, + const steadyState_type&, + const timeCourse_type&, + const fractionalConductance_type&); /** * @brief Create an instance from the ultimate base and @@ -20379,11 +24394,10 @@ namespace neuroml2 * This constructor will try to use the passed values directly * instead of making copies. */ - GateHHRatesInf (const id_type&, - ::std::unique_ptr< forwardRate_type >, - ::std::unique_ptr< reverseRate_type >, - ::std::unique_ptr< steadyState_type >, - const instances_type&); + GateFractionalSubgate (const id_type&, + ::std::unique_ptr< steadyState_type >, + ::std::unique_ptr< timeCourse_type >, + const fractionalConductance_type&); /** * @brief Create an instance from a DOM element. @@ -20393,9 +24407,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - GateHHRatesInf (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateFractionalSubgate (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -20406,9 +24420,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHRatesInf (const GateHHRatesInf& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GateFractionalSubgate (const GateFractionalSubgate& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -20421,7 +24435,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GateHHRatesInf* + virtual GateFractionalSubgate* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -20433,8 +24447,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHRatesInf& - operator= (const GateHHRatesInf& x); + GateFractionalSubgate& + operator= (const GateFractionalSubgate& x); //@} @@ -20442,7 +24456,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GateHHRatesInf (); + ~GateFractionalSubgate (); // Implementation. // @@ -20457,98 +24471,150 @@ namespace neuroml2 protected: notes_optional notes_; q10Settings_optional q10Settings_; - ::xsd::cxx::tree::one< forwardRate_type > forwardRate_; - ::xsd::cxx::tree::one< reverseRate_type > reverseRate_; ::xsd::cxx::tree::one< steadyState_type > steadyState_; - ::xsd::cxx::tree::one< instances_type > instances_; + ::xsd::cxx::tree::one< timeCourse_type > timeCourse_; + ::xsd::cxx::tree::one< fractionalConductance_type > fractionalConductance_; //@endcond }; bool - operator== (const GateHHRatesInf&, const GateHHRatesInf&); + operator== (const GateFractionalSubgate&, const GateFractionalSubgate&); bool - operator!= (const GateHHRatesInf&, const GateHHRatesInf&); + operator!= (const GateFractionalSubgate&, const GateFractionalSubgate&); /** - * @brief Class corresponding to the %GateHHInstantaneous schema type. - * - * Gate which follows the general Hodgkin Huxley formalism but is - * instantaneous, so tau = 0 and gate follows exactly inf value - * @param instances + * @brief Class corresponding to the %Q10Settings schema type. * * @nosubgrouping */ - class GateHHInstantaneous: public ::neuroml2::Base { public: /** - * @name notes + * @name type * - * @brief Accessor and modifier functions for the %notes - * optional element. + * @brief Accessor and modifier functions for the %type + * required attribute. */ //@{ /** - * @brief Element type. + * @brief Attribute type. */ - typedef ::neuroml2::Notes notes_type; + typedef ::neuroml2::NmlId type_type; /** - * @brief Element optional container type. + * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::optional< notes_type > notes_optional; + typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; /** - * @brief Element traits type. + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. */ - typedef ::xsd::cxx::tree::traits< notes_type, char > notes_traits; + const type_type& + type () const; /** - * @brief Return a read-only (constant) reference to the element + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + type_type& + type (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + type (const type_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + type (::std::unique_ptr< type_type > p); + + //@} + + /** + * @name fixedQ10 + * + * @brief Accessor and modifier functions for the %fixedQ10 + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::Nml2Quantity_none fixedQ10_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< fixedQ10_type > fixedQ10_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< fixedQ10_type, char > fixedQ10_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute * container. * * @return A constant reference to the optional container. */ - const notes_optional& - notes () const; + const fixedQ10_optional& + fixedQ10 () const; /** - * @brief Return a read-write reference to the element container. + * @brief Return a read-write reference to the attribute container. * * @return A reference to the optional container. */ - notes_optional& - notes (); + fixedQ10_optional& + fixedQ10 (); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the element. + * the new value of the attribute. */ void - notes (const notes_type& x); + fixedQ10 (const fixedQ10_type& x); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x An optional container with the new value to set. * * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. */ void - notes (const notes_optional& x); + fixedQ10 (const fixedQ10_optional& x); /** - * @brief Set the element value without copying. + * @brief Set the attribute value without copying. * * @param p A new value to use. * @@ -20556,101 +24622,125 @@ namespace neuroml2 * of making a copy. */ void - notes (::std::unique_ptr< notes_type > p); + fixedQ10 (::std::unique_ptr< fixedQ10_type > p); //@} /** - * @name steadyState + * @name q10Factor * - * @brief Accessor and modifier functions for the %steadyState - * required element. + * @brief Accessor and modifier functions for the %q10Factor + * optional attribute. */ //@{ /** - * @brief Element type. + * @brief Attribute type. */ - typedef ::neuroml2::HHVariable steadyState_type; + typedef ::neuroml2::Nml2Quantity_none q10Factor_type; /** - * @brief Element traits type. + * @brief Attribute optional container type. */ - typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; + typedef ::xsd::cxx::tree::optional< q10Factor_type > q10Factor_optional; /** - * @brief Return a read-only (constant) reference to the element. + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< q10Factor_type, char > q10Factor_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. * - * @return A constant reference to the element. + * @return A constant reference to the optional container. */ - const steadyState_type& - steadyState () const; + const q10Factor_optional& + q10Factor () const; /** - * @brief Return a read-write reference to the element. + * @brief Return a read-write reference to the attribute container. * - * @return A reference to the element. + * @return A reference to the optional container. */ - steadyState_type& - steadyState (); + q10Factor_optional& + q10Factor (); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the element. + * the new value of the attribute. */ void - steadyState (const steadyState_type& x); + q10Factor (const q10Factor_type& x); /** - * @brief Set the element value without copying. + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + q10Factor (const q10Factor_optional& x); + + /** + * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - steadyState (::std::unique_ptr< steadyState_type > p); + q10Factor (::std::unique_ptr< q10Factor_type > p); //@} /** - * @name instances + * @name experimentalTemp * - * @brief Accessor and modifier functions for the %instances - * required attribute. + * @brief Accessor and modifier functions for the %experimentalTemp + * optional attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::PositiveInteger instances_type; + typedef ::neuroml2::Nml2Quantity_temperature experimentalTemp_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< experimentalTemp_type > experimentalTemp_optional; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< instances_type, char > instances_traits; + typedef ::xsd::cxx::tree::traits< experimentalTemp_type, char > experimentalTemp_traits; /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Return a read-only (constant) reference to the attribute + * container. * - * @return A constant reference to the attribute. + * @return A constant reference to the optional container. */ - const instances_type& - instances () const; + const experimentalTemp_optional& + experimentalTemp () const; /** - * @brief Return a read-write reference to the attribute. + * @brief Return a read-write reference to the attribute container. * - * @return A reference to the attribute. + * @return A reference to the optional container. */ - instances_type& - instances (); + experimentalTemp_optional& + experimentalTemp (); /** * @brief Set the attribute value. @@ -20661,18 +24751,30 @@ namespace neuroml2 * the new value of the attribute. */ void - instances (const instances_type& x); + experimentalTemp (const experimentalTemp_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + experimentalTemp (const experimentalTemp_optional& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - instances (::std::unique_ptr< instances_type > p); + experimentalTemp (::std::unique_ptr< experimentalTemp_type > p); //@} @@ -20685,21 +24787,7 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GateHHInstantaneous (const id_type&, - const steadyState_type&, - const instances_type&); - - /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes - * (::std::unique_ptr version). - * - * This constructor will try to use the passed values directly - * instead of making copies. - */ - GateHHInstantaneous (const id_type&, - ::std::unique_ptr< steadyState_type >, - const instances_type&); + Q10Settings (const type_type&); /** * @brief Create an instance from a DOM element. @@ -20709,9 +24797,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - GateHHInstantaneous (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + Q10Settings (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -20722,9 +24810,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHInstantaneous (const GateHHInstantaneous& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + Q10Settings (const Q10Settings& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -20737,7 +24825,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GateHHInstantaneous* + virtual Q10Settings* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -20749,8 +24837,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateHHInstantaneous& - operator= (const GateHHInstantaneous& x); + Q10Settings& + operator= (const Q10Settings& x); //@} @@ -20758,7 +24846,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GateHHInstantaneous (); + ~Q10Settings (); // Implementation. // @@ -20771,172 +24859,152 @@ namespace neuroml2 ::xml_schema::flags); protected: - notes_optional notes_; - ::xsd::cxx::tree::one< steadyState_type > steadyState_; - ::xsd::cxx::tree::one< instances_type > instances_; + ::xsd::cxx::tree::one< type_type > type_; + fixedQ10_optional fixedQ10_; + q10Factor_optional q10Factor_; + experimentalTemp_optional experimentalTemp_; //@endcond }; bool - operator== (const GateHHInstantaneous&, const GateHHInstantaneous&); + operator== (const Q10Settings&, const Q10Settings&); bool - operator!= (const GateHHInstantaneous&, const GateHHInstantaneous&); + operator!= (const Q10Settings&, const Q10Settings&); /** - * @brief Class corresponding to the %GateFractional schema type. - * - * Gate composed of subgates contributing with fractional conductance - * @param instances + * @brief Class corresponding to the %HHRate schema type. * * @nosubgrouping */ - class GateFractional: public ::neuroml2::Base + class HHRate: public ::neuroml2::BaseWithoutId { public: /** - * @name notes + * @name type * - * @brief Accessor and modifier functions for the %notes - * optional element. + * @brief Accessor and modifier functions for the %type + * required attribute. */ //@{ /** - * @brief Element type. - */ - typedef ::neuroml2::Notes notes_type; - - /** - * @brief Element optional container type. + * @brief Attribute type. */ - typedef ::xsd::cxx::tree::optional< notes_type > notes_optional; + typedef ::neuroml2::NmlId type_type; /** - * @brief Element traits type. + * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< notes_type, char > notes_traits; + typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; /** - * @brief Return a read-only (constant) reference to the element - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const notes_optional& - notes () const; + const type_type& + type () const; /** - * @brief Return a read-write reference to the element container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - notes_optional& - notes (); + type_type& + type (); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the element. - */ - void - notes (const notes_type& x); - - /** - * @brief Set the element value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. + * the new value of the attribute. */ void - notes (const notes_optional& x); + type (const type_type& x); /** - * @brief Set the element value without copying. + * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - notes (::std::unique_ptr< notes_type > p); + type (::std::unique_ptr< type_type > p); //@} /** - * @name q10Settings + * @name rate * - * @brief Accessor and modifier functions for the %q10Settings - * optional element. + * @brief Accessor and modifier functions for the %rate + * optional attribute. */ //@{ /** - * @brief Element type. + * @brief Attribute type. */ - typedef ::neuroml2::Q10Settings q10Settings_type; + typedef ::neuroml2::Nml2Quantity_pertime rate_type; /** - * @brief Element optional container type. + * @brief Attribute optional container type. */ - typedef ::xsd::cxx::tree::optional< q10Settings_type > q10Settings_optional; + typedef ::xsd::cxx::tree::optional< rate_type > rate_optional; /** - * @brief Element traits type. + * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< q10Settings_type, char > q10Settings_traits; + typedef ::xsd::cxx::tree::traits< rate_type, char > rate_traits; /** - * @brief Return a read-only (constant) reference to the element + * @brief Return a read-only (constant) reference to the attribute * container. * * @return A constant reference to the optional container. */ - const q10Settings_optional& - q10Settings () const; + const rate_optional& + rate () const; /** - * @brief Return a read-write reference to the element container. + * @brief Return a read-write reference to the attribute container. * * @return A reference to the optional container. */ - q10Settings_optional& - q10Settings (); + rate_optional& + rate (); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the element. + * the new value of the attribute. */ void - q10Settings (const q10Settings_type& x); + rate (const rate_type& x); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x An optional container with the new value to set. * * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. */ void - q10Settings (const q10Settings_optional& x); + rate (const rate_optional& x); /** - * @brief Set the element value without copying. + * @brief Set the attribute value without copying. * * @param p A new value to use. * @@ -20944,107 +25012,125 @@ namespace neuroml2 * of making a copy. */ void - q10Settings (::std::unique_ptr< q10Settings_type > p); + rate (::std::unique_ptr< rate_type > p); //@} /** - * @name subGate + * @name midpoint * - * @brief Accessor and modifier functions for the %subGate - * sequence element. + * @brief Accessor and modifier functions for the %midpoint + * optional attribute. */ //@{ /** - * @brief Element type. + * @brief Attribute type. */ - typedef ::neuroml2::GateFractionalSubgate subGate_type; + typedef ::neuroml2::Nml2Quantity_voltage midpoint_type; /** - * @brief Element sequence container type. + * @brief Attribute optional container type. */ - typedef ::xsd::cxx::tree::sequence< subGate_type > subGate_sequence; + typedef ::xsd::cxx::tree::optional< midpoint_type > midpoint_optional; /** - * @brief Element iterator type. + * @brief Attribute traits type. */ - typedef subGate_sequence::iterator subGate_iterator; + typedef ::xsd::cxx::tree::traits< midpoint_type, char > midpoint_traits; /** - * @brief Element constant iterator type. + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. */ - typedef subGate_sequence::const_iterator subGate_const_iterator; + const midpoint_optional& + midpoint () const; /** - * @brief Element traits type. + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. */ - typedef ::xsd::cxx::tree::traits< subGate_type, char > subGate_traits; + midpoint_optional& + midpoint (); /** - * @brief Return a read-only (constant) reference to the element - * sequence. + * @brief Set the attribute value. * - * @return A constant reference to the sequence container. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - const subGate_sequence& - subGate () const; + void + midpoint (const midpoint_type& x); /** - * @brief Return a read-write reference to the element sequence. + * @brief Set the attribute value. * - * @return A reference to the sequence container. + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. */ - subGate_sequence& - subGate (); + void + midpoint (const midpoint_optional& x); /** - * @brief Copy elements from a given sequence. + * @brief Set the attribute value without copying. * - * @param s A sequence to copy elements from. + * @param p A new value to use. * - * For each element in @a s this function makes a copy and adds it - * to the sequence. Note that this operation completely changes the - * sequence and all old elements will be lost. + * This function will try to use the passed value directly instead + * of making a copy. */ void - subGate (const subGate_sequence& s); + midpoint (::std::unique_ptr< midpoint_type > p); //@} /** - * @name instances + * @name scale * - * @brief Accessor and modifier functions for the %instances - * required attribute. + * @brief Accessor and modifier functions for the %scale + * optional attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::PositiveInteger instances_type; + typedef ::neuroml2::Nml2Quantity_voltage scale_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< scale_type > scale_optional; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< instances_type, char > instances_traits; + typedef ::xsd::cxx::tree::traits< scale_type, char > scale_traits; /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Return a read-only (constant) reference to the attribute + * container. * - * @return A constant reference to the attribute. + * @return A constant reference to the optional container. */ - const instances_type& - instances () const; + const scale_optional& + scale () const; /** - * @brief Return a read-write reference to the attribute. + * @brief Return a read-write reference to the attribute container. * - * @return A reference to the attribute. + * @return A reference to the optional container. */ - instances_type& - instances (); + scale_optional& + scale (); /** * @brief Set the attribute value. @@ -21055,18 +25141,30 @@ namespace neuroml2 * the new value of the attribute. */ void - instances (const instances_type& x); + scale (const scale_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + scale (const scale_optional& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - instances (::std::unique_ptr< instances_type > p); + scale (::std::unique_ptr< scale_type > p); //@} @@ -21079,8 +25177,7 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GateFractional (const id_type&, - const instances_type&); + HHRate (const type_type&); /** * @brief Create an instance from a DOM element. @@ -21090,9 +25187,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - GateFractional (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + HHRate (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -21103,9 +25200,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateFractional (const GateFractional& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + HHRate (const HHRate& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -21118,7 +25215,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GateFractional* + virtual HHRate* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -21130,8 +25227,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateFractional& - operator= (const GateFractional& x); + HHRate& + operator= (const HHRate& x); //@} @@ -21139,7 +25236,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GateFractional (); + ~HHRate (); // Implementation. // @@ -21152,330 +25249,267 @@ namespace neuroml2 ::xml_schema::flags); protected: - notes_optional notes_; - q10Settings_optional q10Settings_; - subGate_sequence subGate_; - ::xsd::cxx::tree::one< instances_type > instances_; + ::xsd::cxx::tree::one< type_type > type_; + rate_optional rate_; + midpoint_optional midpoint_; + scale_optional scale_; //@endcond }; bool - operator== (const GateFractional&, const GateFractional&); + operator== (const HHRate&, const HHRate&); bool - operator!= (const GateFractional&, const GateFractional&); + operator!= (const HHRate&, const HHRate&); /** - * @brief Class corresponding to the %GateFractionalSubgate schema type. + * @brief Class corresponding to the %HHVariable schema type. * * @nosubgrouping */ - class GateFractionalSubgate: public ::neuroml2::Base + class HHVariable: public ::neuroml2::BaseWithoutId { public: /** - * @name notes + * @name type * - * @brief Accessor and modifier functions for the %notes - * optional element. + * @brief Accessor and modifier functions for the %type + * required attribute. */ //@{ /** - * @brief Element type. - */ - typedef ::neuroml2::Notes notes_type; - - /** - * @brief Element optional container type. + * @brief Attribute type. */ - typedef ::xsd::cxx::tree::optional< notes_type > notes_optional; + typedef ::neuroml2::NmlId type_type; /** - * @brief Element traits type. + * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< notes_type, char > notes_traits; + typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; /** - * @brief Return a read-only (constant) reference to the element - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const notes_optional& - notes () const; + const type_type& + type () const; /** - * @brief Return a read-write reference to the element container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - notes_optional& - notes (); + type_type& + type (); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the element. - */ - void - notes (const notes_type& x); - - /** - * @brief Set the element value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. + * the new value of the attribute. */ void - notes (const notes_optional& x); + type (const type_type& x); /** - * @brief Set the element value without copying. + * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - notes (::std::unique_ptr< notes_type > p); + type (::std::unique_ptr< type_type > p); //@} /** - * @name q10Settings + * @name rate * - * @brief Accessor and modifier functions for the %q10Settings - * optional element. + * @brief Accessor and modifier functions for the %rate + * optional attribute. */ //@{ /** - * @brief Element type. + * @brief Attribute type. */ - typedef ::neuroml2::Q10Settings q10Settings_type; + typedef ::xml_schema::float_ rate_type; /** - * @brief Element optional container type. + * @brief Attribute optional container type. */ - typedef ::xsd::cxx::tree::optional< q10Settings_type > q10Settings_optional; + typedef ::xsd::cxx::tree::optional< rate_type > rate_optional; /** - * @brief Element traits type. + * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< q10Settings_type, char > q10Settings_traits; + typedef ::xsd::cxx::tree::traits< rate_type, char > rate_traits; /** - * @brief Return a read-only (constant) reference to the element + * @brief Return a read-only (constant) reference to the attribute * container. * * @return A constant reference to the optional container. */ - const q10Settings_optional& - q10Settings () const; + const rate_optional& + rate () const; /** - * @brief Return a read-write reference to the element container. + * @brief Return a read-write reference to the attribute container. * * @return A reference to the optional container. */ - q10Settings_optional& - q10Settings (); + rate_optional& + rate (); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the element. + * the new value of the attribute. */ void - q10Settings (const q10Settings_type& x); + rate (const rate_type& x); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x An optional container with the new value to set. * * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. - */ - void - q10Settings (const q10Settings_optional& x); - - /** - * @brief Set the element value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly instead - * of making a copy. + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. */ void - q10Settings (::std::unique_ptr< q10Settings_type > p); + rate (const rate_optional& x); //@} /** - * @name steadyState + * @name midpoint * - * @brief Accessor and modifier functions for the %steadyState - * required element. + * @brief Accessor and modifier functions for the %midpoint + * optional attribute. */ //@{ /** - * @brief Element type. + * @brief Attribute type. */ - typedef ::neuroml2::HHVariable steadyState_type; + typedef ::neuroml2::Nml2Quantity_voltage midpoint_type; /** - * @brief Element traits type. + * @brief Attribute optional container type. */ - typedef ::xsd::cxx::tree::traits< steadyState_type, char > steadyState_traits; + typedef ::xsd::cxx::tree::optional< midpoint_type > midpoint_optional; /** - * @brief Return a read-only (constant) reference to the element. - * - * @return A constant reference to the element. + * @brief Attribute traits type. */ - const steadyState_type& - steadyState () const; + typedef ::xsd::cxx::tree::traits< midpoint_type, char > midpoint_traits; /** - * @brief Return a read-write reference to the element. + * @brief Return a read-only (constant) reference to the attribute + * container. * - * @return A reference to the element. + * @return A constant reference to the optional container. */ - steadyState_type& - steadyState (); + const midpoint_optional& + midpoint () const; /** - * @brief Set the element value. - * - * @param x A new value to set. + * @brief Return a read-write reference to the attribute container. * - * This function makes a copy of its argument and sets it as - * the new value of the element. + * @return A reference to the optional container. */ - void - steadyState (const steadyState_type& x); + midpoint_optional& + midpoint (); /** - * @brief Set the element value without copying. + * @brief Set the attribute value. * - * @param p A new value to use. + * @param x A new value to set. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ void - steadyState (::std::unique_ptr< steadyState_type > p); - - //@} - - /** - * @name timeCourse - * - * @brief Accessor and modifier functions for the %timeCourse - * required element. - */ - //@{ - - /** - * @brief Element type. - */ - typedef ::neuroml2::HHTime timeCourse_type; - - /** - * @brief Element traits type. - */ - typedef ::xsd::cxx::tree::traits< timeCourse_type, char > timeCourse_traits; - - /** - * @brief Return a read-only (constant) reference to the element. - * - * @return A constant reference to the element. - */ - const timeCourse_type& - timeCourse () const; - - /** - * @brief Return a read-write reference to the element. - * - * @return A reference to the element. - */ - timeCourse_type& - timeCourse (); + midpoint (const midpoint_type& x); /** - * @brief Set the element value. + * @brief Set the attribute value. * - * @param x A new value to set. + * @param x An optional container with the new value to set. * - * This function makes a copy of its argument and sets it as - * the new value of the element. + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. */ void - timeCourse (const timeCourse_type& x); + midpoint (const midpoint_optional& x); /** - * @brief Set the element value without copying. + * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - timeCourse (::std::unique_ptr< timeCourse_type > p); + midpoint (::std::unique_ptr< midpoint_type > p); //@} /** - * @name fractionalConductance + * @name scale * - * @brief Accessor and modifier functions for the %fractionalConductance - * required attribute. + * @brief Accessor and modifier functions for the %scale + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. */ - //@{ + typedef ::neuroml2::Nml2Quantity_voltage scale_type; /** - * @brief Attribute type. + * @brief Attribute optional container type. */ - typedef ::neuroml2::Nml2Quantity_none fractionalConductance_type; + typedef ::xsd::cxx::tree::optional< scale_type > scale_optional; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< fractionalConductance_type, char > fractionalConductance_traits; + typedef ::xsd::cxx::tree::traits< scale_type, char > scale_traits; /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Return a read-only (constant) reference to the attribute + * container. * - * @return A constant reference to the attribute. + * @return A constant reference to the optional container. */ - const fractionalConductance_type& - fractionalConductance () const; + const scale_optional& + scale () const; /** - * @brief Return a read-write reference to the attribute. + * @brief Return a read-write reference to the attribute container. * - * @return A reference to the attribute. + * @return A reference to the optional container. */ - fractionalConductance_type& - fractionalConductance (); + scale_optional& + scale (); /** * @brief Set the attribute value. @@ -21486,18 +25520,30 @@ namespace neuroml2 * the new value of the attribute. */ void - fractionalConductance (const fractionalConductance_type& x); + scale (const scale_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + scale (const scale_optional& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - fractionalConductance (::std::unique_ptr< fractionalConductance_type > p); + scale (::std::unique_ptr< scale_type > p); //@} @@ -21510,23 +25556,7 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GateFractionalSubgate (const id_type&, - const steadyState_type&, - const timeCourse_type&, - const fractionalConductance_type&); - - /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes - * (::std::unique_ptr version). - * - * This constructor will try to use the passed values directly - * instead of making copies. - */ - GateFractionalSubgate (const id_type&, - ::std::unique_ptr< steadyState_type >, - ::std::unique_ptr< timeCourse_type >, - const fractionalConductance_type&); + HHVariable (const type_type&); /** * @brief Create an instance from a DOM element. @@ -21536,9 +25566,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - GateFractionalSubgate (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + HHVariable (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -21549,9 +25579,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateFractionalSubgate (const GateFractionalSubgate& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + HHVariable (const HHVariable& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -21564,7 +25594,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GateFractionalSubgate* + virtual HHVariable* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -21576,8 +25606,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GateFractionalSubgate& - operator= (const GateFractionalSubgate& x); + HHVariable& + operator= (const HHVariable& x); //@} @@ -21585,7 +25615,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GateFractionalSubgate (); + ~HHVariable (); // Implementation. // @@ -21598,27 +25628,27 @@ namespace neuroml2 ::xml_schema::flags); protected: - notes_optional notes_; - q10Settings_optional q10Settings_; - ::xsd::cxx::tree::one< steadyState_type > steadyState_; - ::xsd::cxx::tree::one< timeCourse_type > timeCourse_; - ::xsd::cxx::tree::one< fractionalConductance_type > fractionalConductance_; + ::xsd::cxx::tree::one< type_type > type_; + rate_optional rate_; + midpoint_optional midpoint_; + scale_optional scale_; //@endcond }; bool - operator== (const GateFractionalSubgate&, const GateFractionalSubgate&); + operator== (const HHVariable&, const HHVariable&); bool - operator!= (const GateFractionalSubgate&, const GateFractionalSubgate&); + operator!= (const HHVariable&, const HHVariable&); /** - * @brief Class corresponding to the %Q10Settings schema type. + * @brief Class corresponding to the %HHTime schema type. * * @nosubgrouping */ + class HHTime: public ::neuroml2::BaseWithoutId { public: /** @@ -21680,9 +25710,9 @@ namespace neuroml2 //@} /** - * @name fixedQ10 + * @name rate * - * @brief Accessor and modifier functions for the %fixedQ10 + * @brief Accessor and modifier functions for the %rate * optional attribute. */ //@{ @@ -21690,17 +25720,17 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none fixedQ10_type; + typedef ::neuroml2::Nml2Quantity_time rate_type; /** * @brief Attribute optional container type. */ - typedef ::xsd::cxx::tree::optional< fixedQ10_type > fixedQ10_optional; + typedef ::xsd::cxx::tree::optional< rate_type > rate_optional; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< fixedQ10_type, char > fixedQ10_traits; + typedef ::xsd::cxx::tree::traits< rate_type, char > rate_traits; /** * @brief Return a read-only (constant) reference to the attribute @@ -21708,16 +25738,16 @@ namespace neuroml2 * * @return A constant reference to the optional container. */ - const fixedQ10_optional& - fixedQ10 () const; + const rate_optional& + rate () const; /** * @brief Return a read-write reference to the attribute container. * * @return A reference to the optional container. */ - fixedQ10_optional& - fixedQ10 (); + rate_optional& + rate (); /** * @brief Set the attribute value. @@ -21728,7 +25758,7 @@ namespace neuroml2 * the new value of the attribute. */ void - fixedQ10 (const fixedQ10_type& x); + rate (const rate_type& x); /** * @brief Set the attribute value. @@ -21740,7 +25770,7 @@ namespace neuroml2 * Otherwise the attribute container is set the 'not present' state. */ void - fixedQ10 (const fixedQ10_optional& x); + rate (const rate_optional& x); /** * @brief Set the attribute value without copying. @@ -21751,14 +25781,14 @@ namespace neuroml2 * of making a copy. */ void - fixedQ10 (::std::unique_ptr< fixedQ10_type > p); + rate (::std::unique_ptr< rate_type > p); //@} /** - * @name q10Factor + * @name midpoint * - * @brief Accessor and modifier functions for the %q10Factor + * @brief Accessor and modifier functions for the %midpoint * optional attribute. */ //@{ @@ -21766,17 +25796,17 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none q10Factor_type; + typedef ::neuroml2::Nml2Quantity_voltage midpoint_type; /** * @brief Attribute optional container type. */ - typedef ::xsd::cxx::tree::optional< q10Factor_type > q10Factor_optional; + typedef ::xsd::cxx::tree::optional< midpoint_type > midpoint_optional; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< q10Factor_type, char > q10Factor_traits; + typedef ::xsd::cxx::tree::traits< midpoint_type, char > midpoint_traits; /** * @brief Return a read-only (constant) reference to the attribute @@ -21784,16 +25814,16 @@ namespace neuroml2 * * @return A constant reference to the optional container. */ - const q10Factor_optional& - q10Factor () const; + const midpoint_optional& + midpoint () const; /** * @brief Return a read-write reference to the attribute container. * * @return A reference to the optional container. */ - q10Factor_optional& - q10Factor (); + midpoint_optional& + midpoint (); /** * @brief Set the attribute value. @@ -21804,7 +25834,7 @@ namespace neuroml2 * the new value of the attribute. */ void - q10Factor (const q10Factor_type& x); + midpoint (const midpoint_type& x); /** * @brief Set the attribute value. @@ -21816,7 +25846,7 @@ namespace neuroml2 * Otherwise the attribute container is set the 'not present' state. */ void - q10Factor (const q10Factor_optional& x); + midpoint (const midpoint_optional& x); /** * @brief Set the attribute value without copying. @@ -21827,14 +25857,14 @@ namespace neuroml2 * of making a copy. */ void - q10Factor (::std::unique_ptr< q10Factor_type > p); + midpoint (::std::unique_ptr< midpoint_type > p); //@} /** - * @name experimentalTemp + * @name scale * - * @brief Accessor and modifier functions for the %experimentalTemp + * @brief Accessor and modifier functions for the %scale * optional attribute. */ //@{ @@ -21842,17 +25872,17 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_temperature experimentalTemp_type; + typedef ::neuroml2::Nml2Quantity_voltage scale_type; /** * @brief Attribute optional container type. */ - typedef ::xsd::cxx::tree::optional< experimentalTemp_type > experimentalTemp_optional; + typedef ::xsd::cxx::tree::optional< scale_type > scale_optional; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< experimentalTemp_type, char > experimentalTemp_traits; + typedef ::xsd::cxx::tree::traits< scale_type, char > scale_traits; /** * @brief Return a read-only (constant) reference to the attribute @@ -21860,16 +25890,16 @@ namespace neuroml2 * * @return A constant reference to the optional container. */ - const experimentalTemp_optional& - experimentalTemp () const; + const scale_optional& + scale () const; /** * @brief Return a read-write reference to the attribute container. * * @return A reference to the optional container. */ - experimentalTemp_optional& - experimentalTemp (); + scale_optional& + scale (); /** * @brief Set the attribute value. @@ -21880,7 +25910,7 @@ namespace neuroml2 * the new value of the attribute. */ void - experimentalTemp (const experimentalTemp_type& x); + scale (const scale_type& x); /** * @brief Set the attribute value. @@ -21892,7 +25922,7 @@ namespace neuroml2 * Otherwise the attribute container is set the 'not present' state. */ void - experimentalTemp (const experimentalTemp_optional& x); + scale (const scale_optional& x); /** * @brief Set the attribute value without copying. @@ -21903,7 +25933,83 @@ namespace neuroml2 * of making a copy. */ void - experimentalTemp (::std::unique_ptr< experimentalTemp_type > p); + scale (::std::unique_ptr< scale_type > p); + + //@} + + /** + * @name tau + * + * @brief Accessor and modifier functions for the %tau + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::Nml2Quantity_time tau_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< tau_type > tau_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< tau_type, char > tau_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. + */ + const tau_optional& + tau () const; + + /** + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. + */ + tau_optional& + tau (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + tau (const tau_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + tau (const tau_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + tau (::std::unique_ptr< tau_type > p); //@} @@ -21916,7 +26022,7 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - Q10Settings (const type_type&); + HHTime (const type_type&); /** * @brief Create an instance from a DOM element. @@ -21926,9 +26032,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - Q10Settings (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + HHTime (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -21939,9 +26045,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - Q10Settings (const Q10Settings& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + HHTime (const HHTime& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -21954,7 +26060,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual Q10Settings* + virtual HHTime* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -21966,8 +26072,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - Q10Settings& - operator= (const Q10Settings& x); + HHTime& + operator= (const HHTime& x); //@} @@ -21975,7 +26081,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~Q10Settings (); + ~HHTime (); // Implementation. // @@ -21989,31 +26095,42 @@ namespace neuroml2 protected: ::xsd::cxx::tree::one< type_type > type_; - fixedQ10_optional fixedQ10_; - q10Factor_optional q10Factor_; - experimentalTemp_optional experimentalTemp_; + rate_optional rate_; + midpoint_optional midpoint_; + scale_optional scale_; + tau_optional tau_; //@endcond }; bool - operator== (const Q10Settings&, const Q10Settings&); + operator== (const HHTime&, const HHTime&); bool - operator!= (const Q10Settings&, const Q10Settings&); + operator!= (const HHTime&, const HHTime&); /** - * @brief Class corresponding to the %HHRate schema type. + * @brief Class corresponding to the %DecayingPoolConcentrationModel schema type. + * + * Model of an intracellular buffering mechanism for **ion** ( currently + * hard Coded to be calcium, due to requirement for **iCa** ) which has + * a baseline level **restingConc** and tends to this value with time + * course **decayConstant.** The ion is assumed to occupy a shell inside + * the membrane of thickness **shellThickness.** + * @param restingConc + * @param decayConstant + * @param shellThickness * * @nosubgrouping */ + class DecayingPoolConcentrationModel: public ::neuroml2::Standalone { public: /** - * @name type + * @name ion * - * @brief Accessor and modifier functions for the %type + * @brief Accessor and modifier functions for the %ion * required attribute. */ //@{ @@ -22021,28 +26138,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::NmlId type_type; + typedef ::neuroml2::NmlId ion_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; + typedef ::xsd::cxx::tree::traits< ion_type, char > ion_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const type_type& - type () const; + const ion_type& + ion () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - type_type& - type (); + ion_type& + ion (); /** * @brief Set the attribute value. @@ -22053,7 +26170,7 @@ namespace neuroml2 * the new value of the attribute. */ void - type (const type_type& x); + ion (const ion_type& x); /** * @brief Set the attribute value without copying. @@ -22064,49 +26181,43 @@ namespace neuroml2 * instead of making a copy. */ void - type (::std::unique_ptr< type_type > p); + ion (::std::unique_ptr< ion_type > p); //@} /** - * @name rate + * @name restingConc * - * @brief Accessor and modifier functions for the %rate - * optional attribute. + * @brief Accessor and modifier functions for the %restingConc + * required attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_pertime rate_type; - - /** - * @brief Attribute optional container type. - */ - typedef ::xsd::cxx::tree::optional< rate_type > rate_optional; + typedef ::neuroml2::Nml2Quantity_concentration restingConc_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< rate_type, char > rate_traits; + typedef ::xsd::cxx::tree::traits< restingConc_type, char > restingConc_traits; /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const rate_optional& - rate () const; + const restingConc_type& + restingConc () const; /** - * @brief Return a read-write reference to the attribute container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - rate_optional& - rate (); + restingConc_type& + restingConc (); /** * @brief Set the attribute value. @@ -22117,72 +26228,54 @@ namespace neuroml2 * the new value of the attribute. */ void - rate (const rate_type& x); - - /** - * @brief Set the attribute value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. - */ - void - rate (const rate_optional& x); + restingConc (const restingConc_type& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - rate (::std::unique_ptr< rate_type > p); + restingConc (::std::unique_ptr< restingConc_type > p); //@} /** - * @name midpoint + * @name decayConstant * - * @brief Accessor and modifier functions for the %midpoint - * optional attribute. + * @brief Accessor and modifier functions for the %decayConstant + * required attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage midpoint_type; - - /** - * @brief Attribute optional container type. - */ - typedef ::xsd::cxx::tree::optional< midpoint_type > midpoint_optional; + typedef ::neuroml2::Nml2Quantity_time decayConstant_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< midpoint_type, char > midpoint_traits; + typedef ::xsd::cxx::tree::traits< decayConstant_type, char > decayConstant_traits; /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const midpoint_optional& - midpoint () const; + const decayConstant_type& + decayConstant () const; /** - * @brief Return a read-write reference to the attribute container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - midpoint_optional& - midpoint (); + decayConstant_type& + decayConstant (); /** * @brief Set the attribute value. @@ -22193,72 +26286,54 @@ namespace neuroml2 * the new value of the attribute. */ void - midpoint (const midpoint_type& x); - - /** - * @brief Set the attribute value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. - */ - void - midpoint (const midpoint_optional& x); + decayConstant (const decayConstant_type& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - midpoint (::std::unique_ptr< midpoint_type > p); + decayConstant (::std::unique_ptr< decayConstant_type > p); //@} /** - * @name scale + * @name shellThickness * - * @brief Accessor and modifier functions for the %scale - * optional attribute. + * @brief Accessor and modifier functions for the %shellThickness + * required attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage scale_type; - - /** - * @brief Attribute optional container type. - */ - typedef ::xsd::cxx::tree::optional< scale_type > scale_optional; + typedef ::neuroml2::Nml2Quantity_length shellThickness_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< scale_type, char > scale_traits; + typedef ::xsd::cxx::tree::traits< shellThickness_type, char > shellThickness_traits; /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const scale_optional& - scale () const; + const shellThickness_type& + shellThickness () const; /** - * @brief Return a read-write reference to the attribute container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - scale_optional& - scale (); + shellThickness_type& + shellThickness (); /** * @brief Set the attribute value. @@ -22269,30 +26344,18 @@ namespace neuroml2 * the new value of the attribute. */ void - scale (const scale_type& x); - - /** - * @brief Set the attribute value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. - */ - void - scale (const scale_optional& x); + shellThickness (const shellThickness_type& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - scale (::std::unique_ptr< scale_type > p); + shellThickness (::std::unique_ptr< shellThickness_type > p); //@} @@ -22305,7 +26368,11 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - HHRate (const type_type&); + DecayingPoolConcentrationModel (const id_type&, + const ion_type&, + const restingConc_type&, + const decayConstant_type&, + const shellThickness_type&); /** * @brief Create an instance from a DOM element. @@ -22315,9 +26382,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - HHRate (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + DecayingPoolConcentrationModel (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -22328,9 +26395,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - HHRate (const HHRate& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + DecayingPoolConcentrationModel (const DecayingPoolConcentrationModel& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -22343,7 +26410,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual HHRate* + virtual DecayingPoolConcentrationModel* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -22355,8 +26422,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - HHRate& - operator= (const HHRate& x); + DecayingPoolConcentrationModel& + operator= (const DecayingPoolConcentrationModel& x); //@} @@ -22364,7 +26431,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~HHRate (); + ~DecayingPoolConcentrationModel (); // Implementation. // @@ -22377,32 +26444,43 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< type_type > type_; - rate_optional rate_; - midpoint_optional midpoint_; - scale_optional scale_; + ::xsd::cxx::tree::one< ion_type > ion_; + ::xsd::cxx::tree::one< restingConc_type > restingConc_; + ::xsd::cxx::tree::one< decayConstant_type > decayConstant_; + ::xsd::cxx::tree::one< shellThickness_type > shellThickness_; //@endcond }; bool - operator== (const HHRate&, const HHRate&); + operator== (const DecayingPoolConcentrationModel&, const DecayingPoolConcentrationModel&); bool - operator!= (const HHRate&, const HHRate&); + operator!= (const DecayingPoolConcentrationModel&, const DecayingPoolConcentrationModel&); /** - * @brief Class corresponding to the %HHVariable schema type. + * @brief Class corresponding to the %FixedFactorConcentrationModel schema type. + * + * Model of buffering of concentration of an ion ( currently hard coded + * to be calcium, due to requirement for **iCa** ) which has a baseline + * level **restingConc** and tends to this value with time course + * **decayConstant.** A fixed factor **rho** is used to scale the + * incoming current *independently of the size of the compartment* to + * produce a concentration change. + * @param restingConc + * @param decayConstant + * @param rho * * @nosubgrouping */ + class FixedFactorConcentrationModel: public ::neuroml2::Standalone { public: /** - * @name type + * @name ion * - * @brief Accessor and modifier functions for the %type + * @brief Accessor and modifier functions for the %ion * required attribute. */ //@{ @@ -22410,28 +26488,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::NmlId type_type; + typedef ::neuroml2::NmlId ion_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; + typedef ::xsd::cxx::tree::traits< ion_type, char > ion_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const type_type& - type () const; + const ion_type& + ion () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - type_type& - type (); + ion_type& + ion (); /** * @brief Set the attribute value. @@ -22442,7 +26520,7 @@ namespace neuroml2 * the new value of the attribute. */ void - type (const type_type& x); + ion (const ion_type& x); /** * @brief Set the attribute value without copying. @@ -22453,49 +26531,43 @@ namespace neuroml2 * instead of making a copy. */ void - type (::std::unique_ptr< type_type > p); + ion (::std::unique_ptr< ion_type > p); //@} /** - * @name rate + * @name restingConc * - * @brief Accessor and modifier functions for the %rate - * optional attribute. + * @brief Accessor and modifier functions for the %restingConc + * required attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::xml_schema::float_ rate_type; - - /** - * @brief Attribute optional container type. - */ - typedef ::xsd::cxx::tree::optional< rate_type > rate_optional; + typedef ::neuroml2::Nml2Quantity_concentration restingConc_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< rate_type, char > rate_traits; + typedef ::xsd::cxx::tree::traits< restingConc_type, char > restingConc_traits; /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const rate_optional& - rate () const; + const restingConc_type& + restingConc () const; /** - * @brief Return a read-write reference to the attribute container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - rate_optional& - rate (); + restingConc_type& + restingConc (); /** * @brief Set the attribute value. @@ -22506,61 +26578,54 @@ namespace neuroml2 * the new value of the attribute. */ void - rate (const rate_type& x); + restingConc (const restingConc_type& x); /** - * @brief Set the attribute value. + * @brief Set the attribute value without copying. * - * @param x An optional container with the new value to set. + * @param p A new value to use. * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. + * This function will try to use the passed value directly + * instead of making a copy. */ void - rate (const rate_optional& x); + restingConc (::std::unique_ptr< restingConc_type > p); //@} /** - * @name midpoint + * @name decayConstant * - * @brief Accessor and modifier functions for the %midpoint - * optional attribute. + * @brief Accessor and modifier functions for the %decayConstant + * required attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage midpoint_type; - - /** - * @brief Attribute optional container type. - */ - typedef ::xsd::cxx::tree::optional< midpoint_type > midpoint_optional; + typedef ::neuroml2::Nml2Quantity_time decayConstant_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< midpoint_type, char > midpoint_traits; + typedef ::xsd::cxx::tree::traits< decayConstant_type, char > decayConstant_traits; /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const midpoint_optional& - midpoint () const; + const decayConstant_type& + decayConstant () const; /** - * @brief Return a read-write reference to the attribute container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - midpoint_optional& - midpoint (); + decayConstant_type& + decayConstant (); /** * @brief Set the attribute value. @@ -22571,72 +26636,54 @@ namespace neuroml2 * the new value of the attribute. */ void - midpoint (const midpoint_type& x); - - /** - * @brief Set the attribute value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. - */ - void - midpoint (const midpoint_optional& x); + decayConstant (const decayConstant_type& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - midpoint (::std::unique_ptr< midpoint_type > p); + decayConstant (::std::unique_ptr< decayConstant_type > p); //@} /** - * @name scale + * @name rho * - * @brief Accessor and modifier functions for the %scale - * optional attribute. + * @brief Accessor and modifier functions for the %rho + * required attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage scale_type; - - /** - * @brief Attribute optional container type. - */ - typedef ::xsd::cxx::tree::optional< scale_type > scale_optional; + typedef ::neuroml2::Nml2Quantity_rhoFactor rho_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< scale_type, char > scale_traits; + typedef ::xsd::cxx::tree::traits< rho_type, char > rho_traits; /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const scale_optional& - scale () const; + const rho_type& + rho () const; /** - * @brief Return a read-write reference to the attribute container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - scale_optional& - scale (); + rho_type& + rho (); /** * @brief Set the attribute value. @@ -22647,30 +26694,18 @@ namespace neuroml2 * the new value of the attribute. */ void - scale (const scale_type& x); - - /** - * @brief Set the attribute value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. - */ - void - scale (const scale_optional& x); + rho (const rho_type& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - scale (::std::unique_ptr< scale_type > p); + rho (::std::unique_ptr< rho_type > p); //@} @@ -22683,7 +26718,11 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - HHVariable (const type_type&); + FixedFactorConcentrationModel (const id_type&, + const ion_type&, + const restingConc_type&, + const decayConstant_type&, + const rho_type&); /** * @brief Create an instance from a DOM element. @@ -22693,9 +26732,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - HHVariable (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + FixedFactorConcentrationModel (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -22706,9 +26745,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - HHVariable (const HHVariable& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + FixedFactorConcentrationModel (const FixedFactorConcentrationModel& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -22721,7 +26760,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual HHVariable* + virtual FixedFactorConcentrationModel* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -22733,8 +26772,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - HHVariable& - operator= (const HHVariable& x); + FixedFactorConcentrationModel& + operator= (const FixedFactorConcentrationModel& x); //@} @@ -22742,7 +26781,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~HHVariable (); + ~FixedFactorConcentrationModel (); // Implementation. // @@ -22755,61 +26794,72 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< type_type > type_; - rate_optional rate_; - midpoint_optional midpoint_; - scale_optional scale_; + ::xsd::cxx::tree::one< ion_type > ion_; + ::xsd::cxx::tree::one< restingConc_type > restingConc_; + ::xsd::cxx::tree::one< decayConstant_type > decayConstant_; + ::xsd::cxx::tree::one< rho_type > rho_; //@endcond }; bool - operator== (const HHVariable&, const HHVariable&); + operator== (const FixedFactorConcentrationModel&, const FixedFactorConcentrationModel&); bool - operator!= (const HHVariable&, const HHVariable&); + operator!= (const FixedFactorConcentrationModel&, const FixedFactorConcentrationModel&); /** - * @brief Class corresponding to the %HHTime schema type. + * @brief Class corresponding to the %BaseSynapse schema type. + * + * Base type for all synapses, i. e. ComponentTypes which produce a + * current ( dimension current ) and change Dynamics in response to an + * incoming event. cno_0000009 * * @nosubgrouping */ + class BaseSynapse: public ::neuroml2::Standalone { public: /** - * @name type + * @name neuroLexId * - * @brief Accessor and modifier functions for the %type - * required attribute. + * @brief Accessor and modifier functions for the %neuroLexId + * optional attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::NmlId type_type; + typedef ::neuroml2::NeuroLexId neuroLexId_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< neuroLexId_type > neuroLexId_optional; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; + typedef ::xsd::cxx::tree::traits< neuroLexId_type, char > neuroLexId_traits; /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Return a read-only (constant) reference to the attribute + * container. * - * @return A constant reference to the attribute. + * @return A constant reference to the optional container. */ - const type_type& - type () const; + const neuroLexId_optional& + neuroLexId () const; /** - * @brief Return a read-write reference to the attribute. + * @brief Return a read-write reference to the attribute container. * - * @return A reference to the attribute. + * @return A reference to the optional container. */ - type_type& - type (); + neuroLexId_optional& + neuroLexId (); /** * @brief Set the attribute value. @@ -22820,212 +26870,313 @@ namespace neuroml2 * the new value of the attribute. */ void - type (const type_type& x); + neuroLexId (const neuroLexId_type& x); /** - * @brief Set the attribute value without copying. + * @brief Set the attribute value. * - * @param p A new value to use. + * @param x An optional container with the new value to set. * - * This function will try to use the passed value directly - * instead of making a copy. + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. */ void - type (::std::unique_ptr< type_type > p); - - //@} + neuroLexId (const neuroLexId_optional& x); /** - * @name rate + * @brief Set the attribute value without copying. * - * @brief Accessor and modifier functions for the %rate - * optional attribute. + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. */ - //@{ + void + neuroLexId (::std::unique_ptr< neuroLexId_type > p); - /** - * @brief Attribute type. - */ - typedef ::neuroml2::Nml2Quantity_time rate_type; + //@} /** - * @brief Attribute optional container type. + * @name Constructors */ - typedef ::xsd::cxx::tree::optional< rate_type > rate_optional; + //@{ /** - * @brief Attribute traits type. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. */ - typedef ::xsd::cxx::tree::traits< rate_type, char > rate_traits; + BaseSynapse (const id_type&); /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Create an instance from a DOM element. * - * @return A constant reference to the optional container. + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - const rate_optional& - rate () const; + BaseSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-write reference to the attribute container. + * @brief Copy constructor. * - * @return A reference to the optional container. + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. */ - rate_optional& - rate (); + BaseSynapse (const BaseSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Set the attribute value. + * @brief Copy the instance polymorphically. * - * @param x A new value to set. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - void - rate (const rate_type& x); + virtual BaseSynapse* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; /** - * @brief Set the attribute value. + * @brief Copy assignment operator. * - * @param x An optional container with the new value to set. + * @param x An instance to make a copy of. + * @return A reference to itself. * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. + * For polymorphic object models use the @c _clone function instead. */ - void - rate (const rate_optional& x); + BaseSynapse& + operator= (const BaseSynapse& x); + + //@} /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly instead - * of making a copy. + * @brief Destructor. */ + virtual + ~BaseSynapse (); + + // Implementation. + // + + //@cond + + protected: void - rate (::std::unique_ptr< rate_type > p); + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); - //@} + protected: + neuroLexId_optional neuroLexId_; + + //@endcond + }; + + bool + operator== (const BaseSynapse&, const BaseSynapse&); + + bool + operator!= (const BaseSynapse&, const BaseSynapse&); + + /** + * @brief Class corresponding to the %BaseVoltageDepSynapse schema type. + * + * Base type for synapses with a dependence on membrane potential + * + * @nosubgrouping + */ + class BaseVoltageDepSynapse: public ::neuroml2::BaseSynapse + { + public: /** - * @name midpoint - * - * @brief Accessor and modifier functions for the %midpoint - * optional attribute. + * @name Constructors */ //@{ /** - * @brief Attribute type. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. */ - typedef ::neuroml2::Nml2Quantity_voltage midpoint_type; + BaseVoltageDepSynapse (const id_type&); /** - * @brief Attribute optional container type. + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - typedef ::xsd::cxx::tree::optional< midpoint_type > midpoint_optional; + BaseVoltageDepSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Attribute traits type. + * @brief Copy constructor. + * + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. */ - typedef ::xsd::cxx::tree::traits< midpoint_type, char > midpoint_traits; + BaseVoltageDepSynapse (const BaseVoltageDepSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Copy the instance polymorphically. * - * @return A constant reference to the optional container. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - const midpoint_optional& - midpoint () const; + virtual BaseVoltageDepSynapse* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; + + //@} /** - * @brief Return a read-write reference to the attribute container. - * - * @return A reference to the optional container. + * @brief Destructor. */ - midpoint_optional& - midpoint (); + virtual + ~BaseVoltageDepSynapse (); + }; + + /** + * @brief Class corresponding to the %BaseCurrentBasedSynapse schema type. + * + * Synapse model which produces a synaptic current. + * + * @nosubgrouping + */ + class BaseCurrentBasedSynapse: public ::neuroml2::BaseSynapse + { + public: + /** + * @name Constructors + */ + //@{ /** - * @brief Set the attribute value. - * - * @param x A new value to set. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + BaseCurrentBasedSynapse (const id_type&); + + /** + * @brief Create an instance from a DOM element. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - void - midpoint (const midpoint_type& x); + BaseCurrentBasedSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Set the attribute value. + * @brief Copy constructor. * - * @param x An optional container with the new value to set. + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. + * For polymorphic object models use the @c _clone function instead. */ - void - midpoint (const midpoint_optional& x); + BaseCurrentBasedSynapse (const BaseCurrentBasedSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Set the attribute value without copying. + * @brief Copy the instance polymorphically. * - * @param p A new value to use. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - void - midpoint (::std::unique_ptr< midpoint_type > p); + virtual BaseCurrentBasedSynapse* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; //@} /** - * @name scale - * - * @brief Accessor and modifier functions for the %scale - * optional attribute. + * @brief Destructor. */ - //@{ + virtual + ~BaseCurrentBasedSynapse (); + }; + /** + * @brief Class corresponding to the %BaseConductanceBasedSynapse schema type. + * + * Synapse model which exposes a conductance **g** in addition to + * producing a current. Not necessarily ohmic!! cno_0000027 + * @param gbase Baseline conductance, generally the maximum conductance + * following a single spike + * @param erev Reversal potential of the synapse + * + * @nosubgrouping + */ + class BaseConductanceBasedSynapse: public ::neuroml2::BaseVoltageDepSynapse + { + public: /** - * @brief Attribute type. + * @name gbase + * + * @brief Accessor and modifier functions for the %gbase + * required attribute. */ - typedef ::neuroml2::Nml2Quantity_voltage scale_type; + //@{ /** - * @brief Attribute optional container type. + * @brief Attribute type. */ - typedef ::xsd::cxx::tree::optional< scale_type > scale_optional; + typedef ::neuroml2::Nml2Quantity_conductance gbase_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< scale_type, char > scale_traits; + typedef ::xsd::cxx::tree::traits< gbase_type, char > gbase_traits; /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const scale_optional& - scale () const; + const gbase_type& + gbase () const; /** - * @brief Return a read-write reference to the attribute container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - scale_optional& - scale (); + gbase_type& + gbase (); /** * @brief Set the attribute value. @@ -23036,72 +27187,54 @@ namespace neuroml2 * the new value of the attribute. */ void - scale (const scale_type& x); - - /** - * @brief Set the attribute value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. - */ - void - scale (const scale_optional& x); + gbase (const gbase_type& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - scale (::std::unique_ptr< scale_type > p); + gbase (::std::unique_ptr< gbase_type > p); //@} /** - * @name tau + * @name erev * - * @brief Accessor and modifier functions for the %tau - * optional attribute. + * @brief Accessor and modifier functions for the %erev + * required attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time tau_type; - - /** - * @brief Attribute optional container type. - */ - typedef ::xsd::cxx::tree::optional< tau_type > tau_optional; + typedef ::neuroml2::Nml2Quantity_voltage erev_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< tau_type, char > tau_traits; + typedef ::xsd::cxx::tree::traits< erev_type, char > erev_traits; /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const tau_optional& - tau () const; + const erev_type& + erev () const; /** - * @brief Return a read-write reference to the attribute container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - tau_optional& - tau (); + erev_type& + erev (); /** * @brief Set the attribute value. @@ -23112,30 +27245,18 @@ namespace neuroml2 * the new value of the attribute. */ void - tau (const tau_type& x); - - /** - * @brief Set the attribute value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. - */ - void - tau (const tau_optional& x); + erev (const erev_type& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - tau (::std::unique_ptr< tau_type > p); + erev (::std::unique_ptr< erev_type > p); //@} @@ -23148,7 +27269,9 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - HHTime (const type_type&); + BaseConductanceBasedSynapse (const id_type&, + const gbase_type&, + const erev_type&); /** * @brief Create an instance from a DOM element. @@ -23158,9 +27281,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - HHTime (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + BaseConductanceBasedSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -23171,9 +27294,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - HHTime (const HHTime& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + BaseConductanceBasedSynapse (const BaseConductanceBasedSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -23186,7 +27309,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual HHTime* + virtual BaseConductanceBasedSynapse* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -23198,8 +27321,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - HHTime& - operator= (const HHTime& x); + BaseConductanceBasedSynapse& + operator= (const BaseConductanceBasedSynapse& x); //@} @@ -23207,7 +27330,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~HHTime (); + ~BaseConductanceBasedSynapse (); // Implementation. // @@ -23220,101 +27343,38 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< type_type > type_; - rate_optional rate_; - midpoint_optional midpoint_; - scale_optional scale_; - tau_optional tau_; + ::xsd::cxx::tree::one< gbase_type > gbase_; + ::xsd::cxx::tree::one< erev_type > erev_; //@endcond }; bool - operator== (const HHTime&, const HHTime&); + operator== (const BaseConductanceBasedSynapse&, const BaseConductanceBasedSynapse&); bool - operator!= (const HHTime&, const HHTime&); + operator!= (const BaseConductanceBasedSynapse&, const BaseConductanceBasedSynapse&); /** - * @brief Class corresponding to the %DecayingPoolConcentrationModel schema type. + * @brief Class corresponding to the %BaseConductanceBasedSynapseTwo schema type. * - * Model of an intracellular buffering mechanism for **ion** ( currently - * hard Coded to be calcium, due to requirement for **iCa** ) which has - * a baseline level **restingConc** and tends to this value with time - * course **decayConstant.** The ion is assumed to occupy a shell inside - * the membrane of thickness **shellThickness.** - * @param restingConc - * @param decayConstant - * @param shellThickness + * Synapse model suited for a sum of two expTwoSynapses which exposes a + * conductance **g** in addition to producing a current. Not necessarily + * ohmic!! cno_0000027 + * @param gbase1 Baseline conductance 1 + * @param gbase2 Baseline conductance 2 + * @param erev Reversal potential of the synapse * * @nosubgrouping */ - class DecayingPoolConcentrationModel: public ::neuroml2::Standalone + class BaseConductanceBasedSynapseTwo: public ::neuroml2::BaseVoltageDepSynapse { public: /** - * @name ion - * - * @brief Accessor and modifier functions for the %ion - * required attribute. - */ - //@{ - - /** - * @brief Attribute type. - */ - typedef ::neuroml2::NmlId ion_type; - - /** - * @brief Attribute traits type. - */ - typedef ::xsd::cxx::tree::traits< ion_type, char > ion_traits; - - /** - * @brief Return a read-only (constant) reference to the attribute. - * - * @return A constant reference to the attribute. - */ - const ion_type& - ion () const; - - /** - * @brief Return a read-write reference to the attribute. - * - * @return A reference to the attribute. - */ - ion_type& - ion (); - - /** - * @brief Set the attribute value. - * - * @param x A new value to set. - * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. - */ - void - ion (const ion_type& x); - - /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. - */ - void - ion (::std::unique_ptr< ion_type > p); - - //@} - - /** - * @name restingConc + * @name gbase1 * - * @brief Accessor and modifier functions for the %restingConc + * @brief Accessor and modifier functions for the %gbase1 * required attribute. */ //@{ @@ -23322,28 +27382,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_concentration restingConc_type; + typedef ::neuroml2::Nml2Quantity_conductance gbase1_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< restingConc_type, char > restingConc_traits; + typedef ::xsd::cxx::tree::traits< gbase1_type, char > gbase1_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const restingConc_type& - restingConc () const; + const gbase1_type& + gbase1 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - restingConc_type& - restingConc (); + gbase1_type& + gbase1 (); /** * @brief Set the attribute value. @@ -23354,7 +27414,7 @@ namespace neuroml2 * the new value of the attribute. */ void - restingConc (const restingConc_type& x); + gbase1 (const gbase1_type& x); /** * @brief Set the attribute value without copying. @@ -23365,14 +27425,14 @@ namespace neuroml2 * instead of making a copy. */ void - restingConc (::std::unique_ptr< restingConc_type > p); + gbase1 (::std::unique_ptr< gbase1_type > p); //@} /** - * @name decayConstant + * @name gbase2 * - * @brief Accessor and modifier functions for the %decayConstant + * @brief Accessor and modifier functions for the %gbase2 * required attribute. */ //@{ @@ -23380,28 +27440,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time decayConstant_type; + typedef ::neuroml2::Nml2Quantity_conductance gbase2_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< decayConstant_type, char > decayConstant_traits; + typedef ::xsd::cxx::tree::traits< gbase2_type, char > gbase2_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const decayConstant_type& - decayConstant () const; + const gbase2_type& + gbase2 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - decayConstant_type& - decayConstant (); + gbase2_type& + gbase2 (); /** * @brief Set the attribute value. @@ -23412,7 +27472,7 @@ namespace neuroml2 * the new value of the attribute. */ void - decayConstant (const decayConstant_type& x); + gbase2 (const gbase2_type& x); /** * @brief Set the attribute value without copying. @@ -23423,14 +27483,14 @@ namespace neuroml2 * instead of making a copy. */ void - decayConstant (::std::unique_ptr< decayConstant_type > p); + gbase2 (::std::unique_ptr< gbase2_type > p); //@} /** - * @name shellThickness + * @name erev * - * @brief Accessor and modifier functions for the %shellThickness + * @brief Accessor and modifier functions for the %erev * required attribute. */ //@{ @@ -23438,28 +27498,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_length shellThickness_type; + typedef ::neuroml2::Nml2Quantity_voltage erev_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< shellThickness_type, char > shellThickness_traits; + typedef ::xsd::cxx::tree::traits< erev_type, char > erev_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const shellThickness_type& - shellThickness () const; + const erev_type& + erev () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - shellThickness_type& - shellThickness (); + erev_type& + erev (); /** * @brief Set the attribute value. @@ -23470,7 +27530,7 @@ namespace neuroml2 * the new value of the attribute. */ void - shellThickness (const shellThickness_type& x); + erev (const erev_type& x); /** * @brief Set the attribute value without copying. @@ -23481,7 +27541,7 @@ namespace neuroml2 * instead of making a copy. */ void - shellThickness (::std::unique_ptr< shellThickness_type > p); + erev (::std::unique_ptr< erev_type > p); //@} @@ -23494,11 +27554,10 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - DecayingPoolConcentrationModel (const id_type&, - const ion_type&, - const restingConc_type&, - const decayConstant_type&, - const shellThickness_type&); + BaseConductanceBasedSynapseTwo (const id_type&, + const gbase1_type&, + const gbase2_type&, + const erev_type&); /** * @brief Create an instance from a DOM element. @@ -23508,7 +27567,7 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - DecayingPoolConcentrationModel (const ::xercesc::DOMElement& e, + BaseConductanceBasedSynapseTwo (const ::xercesc::DOMElement& e, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -23521,7 +27580,7 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - DecayingPoolConcentrationModel (const DecayingPoolConcentrationModel& x, + BaseConductanceBasedSynapseTwo (const BaseConductanceBasedSynapseTwo& x, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -23536,7 +27595,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual DecayingPoolConcentrationModel* + virtual BaseConductanceBasedSynapseTwo* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -23548,8 +27607,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - DecayingPoolConcentrationModel& - operator= (const DecayingPoolConcentrationModel& x); + BaseConductanceBasedSynapseTwo& + operator= (const BaseConductanceBasedSynapseTwo& x); //@} @@ -23557,7 +27616,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~DecayingPoolConcentrationModel (); + ~BaseConductanceBasedSynapseTwo (); // Implementation. // @@ -23570,43 +27629,35 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< ion_type > ion_; - ::xsd::cxx::tree::one< restingConc_type > restingConc_; - ::xsd::cxx::tree::one< decayConstant_type > decayConstant_; - ::xsd::cxx::tree::one< shellThickness_type > shellThickness_; + ::xsd::cxx::tree::one< gbase1_type > gbase1_; + ::xsd::cxx::tree::one< gbase2_type > gbase2_; + ::xsd::cxx::tree::one< erev_type > erev_; //@endcond }; bool - operator== (const DecayingPoolConcentrationModel&, const DecayingPoolConcentrationModel&); + operator== (const BaseConductanceBasedSynapseTwo&, const BaseConductanceBasedSynapseTwo&); bool - operator!= (const DecayingPoolConcentrationModel&, const DecayingPoolConcentrationModel&); + operator!= (const BaseConductanceBasedSynapseTwo&, const BaseConductanceBasedSynapseTwo&); /** - * @brief Class corresponding to the %FixedFactorConcentrationModel schema type. + * @brief Class corresponding to the %GapJunction schema type. * - * Model of buffering of concentration of an ion ( currently hard coded - * to be calcium, due to requirement for **iCa** ) which has a baseline - * level **restingConc** and tends to this value with time course - * **decayConstant.** A fixed factor **rho** is used to scale the - * incoming current *independently of the size of the compartment* to - * produce a concentration change. - * @param restingConc - * @param decayConstant - * @param rho + * Gap junction/single electrical connection + * @param conductance * * @nosubgrouping */ - class FixedFactorConcentrationModel: public ::neuroml2::Standalone + class GapJunction: public ::neuroml2::BaseSynapse { public: /** - * @name ion + * @name conductance * - * @brief Accessor and modifier functions for the %ion + * @brief Accessor and modifier functions for the %conductance * required attribute. */ //@{ @@ -23614,28 +27665,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::NmlId ion_type; + typedef ::neuroml2::Nml2Quantity_conductance conductance_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< ion_type, char > ion_traits; + typedef ::xsd::cxx::tree::traits< conductance_type, char > conductance_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const ion_type& - ion () const; + const conductance_type& + conductance () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - ion_type& - ion (); + conductance_type& + conductance (); /** * @brief Set the attribute value. @@ -23646,7 +27697,7 @@ namespace neuroml2 * the new value of the attribute. */ void - ion (const ion_type& x); + conductance (const conductance_type& x); /** * @brief Set the attribute value without copying. @@ -23657,130 +27708,190 @@ namespace neuroml2 * instead of making a copy. */ void - ion (::std::unique_ptr< ion_type > p); + conductance (::std::unique_ptr< conductance_type > p); //@} /** - * @name restingConc - * - * @brief Accessor and modifier functions for the %restingConc - * required attribute. + * @name Constructors */ //@{ /** - * @brief Attribute type. - */ - typedef ::neuroml2::Nml2Quantity_concentration restingConc_type; - - /** - * @brief Attribute traits type. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. */ - typedef ::xsd::cxx::tree::traits< restingConc_type, char > restingConc_traits; + GapJunction (const id_type&, + const conductance_type&); /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Create an instance from a DOM element. * - * @return A constant reference to the attribute. + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - const restingConc_type& - restingConc () const; + GapJunction (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-write reference to the attribute. + * @brief Copy constructor. * - * @return A reference to the attribute. + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. */ - restingConc_type& - restingConc (); + GapJunction (const GapJunction& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Set the attribute value. + * @brief Copy the instance polymorphically. * - * @param x A new value to set. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - void - restingConc (const restingConc_type& x); + virtual GapJunction* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; /** - * @brief Set the attribute value without copying. + * @brief Copy assignment operator. * - * @param p A new value to use. + * @param x An instance to make a copy of. + * @return A reference to itself. * - * This function will try to use the passed value directly - * instead of making a copy. + * For polymorphic object models use the @c _clone function instead. */ - void - restingConc (::std::unique_ptr< restingConc_type > p); + GapJunction& + operator= (const GapJunction& x); //@} /** - * @name decayConstant - * - * @brief Accessor and modifier functions for the %decayConstant - * required attribute. + * @brief Destructor. */ - //@{ + virtual + ~GapJunction (); - /** - * @brief Attribute type. - */ - typedef ::neuroml2::Nml2Quantity_time decayConstant_type; + // Implementation. + // + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< conductance_type > conductance_; + + //@endcond + }; + + bool + operator== (const GapJunction&, const GapJunction&); + + bool + operator!= (const GapJunction&, const GapJunction&); + + + /** + * @brief Class corresponding to the %SilentSynapse schema type. + * + * Dummy synapse which emits no current. Used as presynaptic endpoint for + * analog synaptic connection. + * + * @nosubgrouping + */ + class SilentSynapse: public ::neuroml2::BaseSynapse + { + public: /** - * @brief Attribute traits type. + * @name Constructors */ - typedef ::xsd::cxx::tree::traits< decayConstant_type, char > decayConstant_traits; + //@{ /** - * @brief Return a read-only (constant) reference to the attribute. - * - * @return A constant reference to the attribute. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. */ - const decayConstant_type& - decayConstant () const; + SilentSynapse (const id_type&); /** - * @brief Return a read-write reference to the attribute. + * @brief Create an instance from a DOM element. * - * @return A reference to the attribute. + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - decayConstant_type& - decayConstant (); + SilentSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Set the attribute value. + * @brief Copy constructor. * - * @param x A new value to set. + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * For polymorphic object models use the @c _clone function instead. */ - void - decayConstant (const decayConstant_type& x); + SilentSynapse (const SilentSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Set the attribute value without copying. + * @brief Copy the instance polymorphically. * - * @param p A new value to use. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - void - decayConstant (::std::unique_ptr< decayConstant_type > p); + virtual SilentSynapse* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; //@} /** - * @name rho + * @brief Destructor. + */ + virtual + ~SilentSynapse (); + }; + + /** + * @brief Class corresponding to the %LinearGradedSynapse schema type. + * + * Behaves just like a one way gap junction. + * @param conductance + * + * @nosubgrouping + */ + class LinearGradedSynapse: public ::neuroml2::BaseSynapse + { + public: + /** + * @name conductance * - * @brief Accessor and modifier functions for the %rho + * @brief Accessor and modifier functions for the %conductance * required attribute. */ //@{ @@ -23788,28 +27899,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_rhoFactor rho_type; + typedef ::neuroml2::Nml2Quantity_conductance conductance_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< rho_type, char > rho_traits; + typedef ::xsd::cxx::tree::traits< conductance_type, char > conductance_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const rho_type& - rho () const; + const conductance_type& + conductance () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - rho_type& - rho (); + conductance_type& + conductance (); /** * @brief Set the attribute value. @@ -23820,7 +27931,7 @@ namespace neuroml2 * the new value of the attribute. */ void - rho (const rho_type& x); + conductance (const conductance_type& x); /** * @brief Set the attribute value without copying. @@ -23831,7 +27942,7 @@ namespace neuroml2 * instead of making a copy. */ void - rho (::std::unique_ptr< rho_type > p); + conductance (::std::unique_ptr< conductance_type > p); //@} @@ -23844,11 +27955,8 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - FixedFactorConcentrationModel (const id_type&, - const ion_type&, - const restingConc_type&, - const decayConstant_type&, - const rho_type&); + LinearGradedSynapse (const id_type&, + const conductance_type&); /** * @brief Create an instance from a DOM element. @@ -23858,9 +27966,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - FixedFactorConcentrationModel (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + LinearGradedSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -23871,9 +27979,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - FixedFactorConcentrationModel (const FixedFactorConcentrationModel& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + LinearGradedSynapse (const LinearGradedSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -23886,7 +27994,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual FixedFactorConcentrationModel* + virtual LinearGradedSynapse* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -23898,8 +28006,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - FixedFactorConcentrationModel& - operator= (const FixedFactorConcentrationModel& x); + LinearGradedSynapse& + operator= (const LinearGradedSynapse& x); //@} @@ -23907,7 +28015,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~FixedFactorConcentrationModel (); + ~LinearGradedSynapse (); // Implementation. // @@ -23920,251 +28028,212 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< ion_type > ion_; - ::xsd::cxx::tree::one< restingConc_type > restingConc_; - ::xsd::cxx::tree::one< decayConstant_type > decayConstant_; - ::xsd::cxx::tree::one< rho_type > rho_; + ::xsd::cxx::tree::one< conductance_type > conductance_; //@endcond }; bool - operator== (const FixedFactorConcentrationModel&, const FixedFactorConcentrationModel&); + operator== (const LinearGradedSynapse&, const LinearGradedSynapse&); bool - operator!= (const FixedFactorConcentrationModel&, const FixedFactorConcentrationModel&); + operator!= (const LinearGradedSynapse&, const LinearGradedSynapse&); /** - * @brief Class corresponding to the %BaseSynapse schema type. + * @brief Class corresponding to the %GradedSynapse schema type. * - * Base type for all synapses, i. e. ComponentTypes which produce a - * current ( dimension current ) and change Dynamics in response to an - * incoming event. cno_0000009 + * Graded/analog synapse. Based on synapse in Methods of http://www. + * nature.com/neuro/journal/v7/n12/abs/nn1352.html + * @param conductance + * @param delta Slope of the activation curve + * @param k Rate constant for transmitter-receptor dissociation rate + * @param Vth The half-activation voltage of the synapse + * @param erev The reversal potential of the synapse * * @nosubgrouping */ - class BaseSynapse: public ::neuroml2::Standalone + class GradedSynapse: public ::neuroml2::BaseSynapse { public: /** - * @name Constructors + * @name conductance + * + * @brief Accessor and modifier functions for the %conductance + * required attribute. */ //@{ /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Attribute type. */ - BaseSynapse (const id_type&); + typedef ::neuroml2::Nml2Quantity_conductance conductance_type; /** - * @brief Create an instance from a DOM element. + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< conductance_type, char > conductance_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @return A constant reference to the attribute. */ - BaseSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + const conductance_type& + conductance () const; /** - * @brief Copy constructor. + * @brief Return a read-write reference to the attribute. * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. + * @return A reference to the attribute. + */ + conductance_type& + conductance (); + + /** + * @brief Set the attribute value. * - * For polymorphic object models use the @c _clone function instead. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - BaseSynapse (const BaseSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + void + conductance (const conductance_type& x); /** - * @brief Copy the instance polymorphically. + * @brief Set the attribute value without copying. * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. + * @param p A new value to use. * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. + * This function will try to use the passed value directly + * instead of making a copy. */ - virtual BaseSynapse* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; + void + conductance (::std::unique_ptr< conductance_type > p); //@} /** - * @brief Destructor. + * @name delta + * + * @brief Accessor and modifier functions for the %delta + * required attribute. */ - virtual - ~BaseSynapse (); - }; + //@{ - /** - * @brief Class corresponding to the %BaseVoltageDepSynapse schema type. - * - * Base type for synapses with a dependence on membrane potential - * - * @nosubgrouping - */ - class BaseVoltageDepSynapse: public ::neuroml2::BaseSynapse - { - public: /** - * @name Constructors + * @brief Attribute type. */ - //@{ + typedef ::neuroml2::Nml2Quantity_voltage delta_type; /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Attribute traits type. */ - BaseVoltageDepSynapse (const id_type&); + typedef ::xsd::cxx::tree::traits< delta_type, char > delta_traits; /** - * @brief Create an instance from a DOM element. + * @brief Return a read-only (constant) reference to the attribute. * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @return A constant reference to the attribute. */ - BaseVoltageDepSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + const delta_type& + delta () const; /** - * @brief Copy constructor. + * @brief Return a read-write reference to the attribute. * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. + * @return A reference to the attribute. + */ + delta_type& + delta (); + + /** + * @brief Set the attribute value. * - * For polymorphic object models use the @c _clone function instead. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - BaseVoltageDepSynapse (const BaseVoltageDepSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + void + delta (const delta_type& x); /** - * @brief Copy the instance polymorphically. + * @brief Set the attribute value without copying. * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. + * @param p A new value to use. * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. + * This function will try to use the passed value directly + * instead of making a copy. */ - virtual BaseVoltageDepSynapse* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; + void + delta (::std::unique_ptr< delta_type > p); //@} /** - * @brief Destructor. + * @name Vth + * + * @brief Accessor and modifier functions for the %Vth + * required attribute. */ - virtual - ~BaseVoltageDepSynapse (); - }; + //@{ - /** - * @brief Class corresponding to the %BaseCurrentBasedSynapse schema type. - * - * Synapse model which produces a synaptic current. - * - * @nosubgrouping - */ - class BaseCurrentBasedSynapse: public ::neuroml2::BaseSynapse - { - public: /** - * @name Constructors + * @brief Attribute type. */ - //@{ + typedef ::neuroml2::Nml2Quantity_voltage Vth_type; /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Attribute traits type. */ - BaseCurrentBasedSynapse (const id_type&); + typedef ::xsd::cxx::tree::traits< Vth_type, char > Vth_traits; /** - * @brief Create an instance from a DOM element. + * @brief Return a read-only (constant) reference to the attribute. * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @return A constant reference to the attribute. */ - BaseCurrentBasedSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + const Vth_type& + Vth () const; /** - * @brief Copy constructor. - * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. + * @brief Return a read-write reference to the attribute. * - * For polymorphic object models use the @c _clone function instead. + * @return A reference to the attribute. */ - BaseCurrentBasedSynapse (const BaseCurrentBasedSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + Vth_type& + Vth (); /** - * @brief Copy the instance polymorphically. + * @brief Set the attribute value. * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. + * @param x A new value to set. * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - virtual BaseCurrentBasedSynapse* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; - - //@} + void + Vth (const Vth_type& x); /** - * @brief Destructor. + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. */ - virtual - ~BaseCurrentBasedSynapse (); - }; + void + Vth (::std::unique_ptr< Vth_type > p); + + //@} - /** - * @brief Class corresponding to the %BaseConductanceBasedSynapse schema type. - * - * Synapse model which exposes a conductance **g** in addition to - * producing a current. Not necessarily ohmic!! cno_0000027 - * @param gbase Baseline conductance, generally the maximum conductance - * following a single spike - * @param erev Reversal potential of the synapse - * - * @nosubgrouping - */ - class BaseConductanceBasedSynapse: public ::neuroml2::BaseVoltageDepSynapse - { - public: /** - * @name gbase + * @name k * - * @brief Accessor and modifier functions for the %gbase + * @brief Accessor and modifier functions for the %k * required attribute. */ //@{ @@ -24172,28 +28241,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductance gbase_type; + typedef ::neuroml2::Nml2Quantity_pertime k_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gbase_type, char > gbase_traits; + typedef ::xsd::cxx::tree::traits< k_type, char > k_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gbase_type& - gbase () const; + const k_type& + k () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gbase_type& - gbase (); + k_type& + k (); /** * @brief Set the attribute value. @@ -24204,7 +28273,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gbase (const gbase_type& x); + k (const k_type& x); /** * @brief Set the attribute value without copying. @@ -24215,7 +28284,7 @@ namespace neuroml2 * instead of making a copy. */ void - gbase (::std::unique_ptr< gbase_type > p); + k (::std::unique_ptr< k_type > p); //@} @@ -24286,9 +28355,12 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - BaseConductanceBasedSynapse (const id_type&, - const gbase_type&, - const erev_type&); + GradedSynapse (const id_type&, + const conductance_type&, + const delta_type&, + const Vth_type&, + const k_type&, + const erev_type&); /** * @brief Create an instance from a DOM element. @@ -24298,9 +28370,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - BaseConductanceBasedSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GradedSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -24311,9 +28383,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BaseConductanceBasedSynapse (const BaseConductanceBasedSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + GradedSynapse (const GradedSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -24326,7 +28398,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual BaseConductanceBasedSynapse* + virtual GradedSynapse* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -24338,8 +28410,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BaseConductanceBasedSynapse& - operator= (const BaseConductanceBasedSynapse& x); + GradedSynapse& + operator= (const GradedSynapse& x); //@} @@ -24347,7 +28419,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~BaseConductanceBasedSynapse (); + ~GradedSynapse (); // Implementation. // @@ -24360,96 +28432,38 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< gbase_type > gbase_; + ::xsd::cxx::tree::one< conductance_type > conductance_; + ::xsd::cxx::tree::one< delta_type > delta_; + ::xsd::cxx::tree::one< Vth_type > Vth_; + ::xsd::cxx::tree::one< k_type > k_; ::xsd::cxx::tree::one< erev_type > erev_; //@endcond }; bool - operator== (const BaseConductanceBasedSynapse&, const BaseConductanceBasedSynapse&); + operator== (const GradedSynapse&, const GradedSynapse&); bool - operator!= (const BaseConductanceBasedSynapse&, const BaseConductanceBasedSynapse&); + operator!= (const GradedSynapse&, const GradedSynapse&); /** - * @brief Class corresponding to the %BaseConductanceBasedSynapseTwo schema type. + * @brief Class corresponding to the %AlphaCurrentSynapse schema type. * - * Synapse model suited for a sum of two expTwoSynapses which exposes a - * conductance **g** in addition to producing a current. Not necessarily - * ohmic!! cno_0000027 - * @param gbase1 Baseline conductance 1 - * @param gbase2 Baseline conductance 2 - * @param erev Reversal potential of the synapse + * Alpha current synapse: rise time and decay time are both **tau.** + * @param tau Time course for rise and decay + * @param ibase Baseline current increase after receiving a spike * * @nosubgrouping */ - class BaseConductanceBasedSynapseTwo: public ::neuroml2::BaseVoltageDepSynapse + class AlphaCurrentSynapse: public ::neuroml2::BaseCurrentBasedSynapse { public: /** - * @name gbase1 - * - * @brief Accessor and modifier functions for the %gbase1 - * required attribute. - */ - //@{ - - /** - * @brief Attribute type. - */ - typedef ::neuroml2::Nml2Quantity_conductance gbase1_type; - - /** - * @brief Attribute traits type. - */ - typedef ::xsd::cxx::tree::traits< gbase1_type, char > gbase1_traits; - - /** - * @brief Return a read-only (constant) reference to the attribute. - * - * @return A constant reference to the attribute. - */ - const gbase1_type& - gbase1 () const; - - /** - * @brief Return a read-write reference to the attribute. - * - * @return A reference to the attribute. - */ - gbase1_type& - gbase1 (); - - /** - * @brief Set the attribute value. - * - * @param x A new value to set. - * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. - */ - void - gbase1 (const gbase1_type& x); - - /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. - */ - void - gbase1 (::std::unique_ptr< gbase1_type > p); - - //@} - - /** - * @name gbase2 + * @name tau * - * @brief Accessor and modifier functions for the %gbase2 + * @brief Accessor and modifier functions for the %tau * required attribute. */ //@{ @@ -24457,28 +28471,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductance gbase2_type; + typedef ::neuroml2::Nml2Quantity_time tau_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gbase2_type, char > gbase2_traits; + typedef ::xsd::cxx::tree::traits< tau_type, char > tau_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gbase2_type& - gbase2 () const; + const tau_type& + tau () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gbase2_type& - gbase2 (); + tau_type& + tau (); /** * @brief Set the attribute value. @@ -24489,7 +28503,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gbase2 (const gbase2_type& x); + tau (const tau_type& x); /** * @brief Set the attribute value without copying. @@ -24500,14 +28514,14 @@ namespace neuroml2 * instead of making a copy. */ void - gbase2 (::std::unique_ptr< gbase2_type > p); + tau (::std::unique_ptr< tau_type > p); //@} /** - * @name erev + * @name ibase * - * @brief Accessor and modifier functions for the %erev + * @brief Accessor and modifier functions for the %ibase * required attribute. */ //@{ @@ -24515,28 +28529,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage erev_type; + typedef ::neuroml2::Nml2Quantity_current ibase_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< erev_type, char > erev_traits; + typedef ::xsd::cxx::tree::traits< ibase_type, char > ibase_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const erev_type& - erev () const; + const ibase_type& + ibase () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - erev_type& - erev (); + ibase_type& + ibase (); /** * @brief Set the attribute value. @@ -24547,7 +28561,7 @@ namespace neuroml2 * the new value of the attribute. */ void - erev (const erev_type& x); + ibase (const ibase_type& x); /** * @brief Set the attribute value without copying. @@ -24558,7 +28572,7 @@ namespace neuroml2 * instead of making a copy. */ void - erev (::std::unique_ptr< erev_type > p); + ibase (::std::unique_ptr< ibase_type > p); //@} @@ -24571,10 +28585,9 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - BaseConductanceBasedSynapseTwo (const id_type&, - const gbase1_type&, - const gbase2_type&, - const erev_type&); + AlphaCurrentSynapse (const id_type&, + const tau_type&, + const ibase_type&); /** * @brief Create an instance from a DOM element. @@ -24584,9 +28597,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - BaseConductanceBasedSynapseTwo (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + AlphaCurrentSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -24597,9 +28610,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BaseConductanceBasedSynapseTwo (const BaseConductanceBasedSynapseTwo& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + AlphaCurrentSynapse (const AlphaCurrentSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -24612,7 +28625,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual BaseConductanceBasedSynapseTwo* + virtual AlphaCurrentSynapse* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -24624,8 +28637,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BaseConductanceBasedSynapseTwo& - operator= (const BaseConductanceBasedSynapseTwo& x); + AlphaCurrentSynapse& + operator= (const AlphaCurrentSynapse& x); //@} @@ -24633,7 +28646,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~BaseConductanceBasedSynapseTwo (); + ~AlphaCurrentSynapse (); // Implementation. // @@ -24646,35 +28659,39 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< gbase1_type > gbase1_; - ::xsd::cxx::tree::one< gbase2_type > gbase2_; - ::xsd::cxx::tree::one< erev_type > erev_; + ::xsd::cxx::tree::one< tau_type > tau_; + ::xsd::cxx::tree::one< ibase_type > ibase_; //@endcond }; bool - operator== (const BaseConductanceBasedSynapseTwo&, const BaseConductanceBasedSynapseTwo&); + operator== (const AlphaCurrentSynapse&, const AlphaCurrentSynapse&); bool - operator!= (const BaseConductanceBasedSynapseTwo&, const BaseConductanceBasedSynapseTwo&); + operator!= (const AlphaCurrentSynapse&, const AlphaCurrentSynapse&); /** - * @brief Class corresponding to the %GapJunction schema type. + * @brief Class corresponding to the %AlphaSynapse schema type. * - * Gap junction/single electrical connection - * @param conductance + * Ohmic synapse model where rise time and decay time are both **tau.** + * Max conductance reached during this time ( assuming zero conductance + * before ) is **gbase** * **weight.** + * @param tau Time course of rise/decay + * @param gbase Baseline conductance, generally the maximum conductance + * following a single spike + * @param erev Reversal potential of the synapse * * @nosubgrouping */ - class GapJunction: public ::neuroml2::BaseSynapse + class AlphaSynapse: public ::neuroml2::BaseConductanceBasedSynapse { public: /** - * @name conductance + * @name tau * - * @brief Accessor and modifier functions for the %conductance + * @brief Accessor and modifier functions for the %tau * required attribute. */ //@{ @@ -24682,28 +28699,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductance conductance_type; + typedef ::neuroml2::Nml2Quantity_time tau_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< conductance_type, char > conductance_traits; + typedef ::xsd::cxx::tree::traits< tau_type, char > tau_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const conductance_type& - conductance () const; + const tau_type& + tau () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - conductance_type& - conductance (); + tau_type& + tau (); /** * @brief Set the attribute value. @@ -24714,7 +28731,7 @@ namespace neuroml2 * the new value of the attribute. */ void - conductance (const conductance_type& x); + tau (const tau_type& x); /** * @brief Set the attribute value without copying. @@ -24725,7 +28742,7 @@ namespace neuroml2 * instead of making a copy. */ void - conductance (::std::unique_ptr< conductance_type > p); + tau (::std::unique_ptr< tau_type > p); //@} @@ -24738,8 +28755,10 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GapJunction (const id_type&, - const conductance_type&); + AlphaSynapse (const id_type&, + const gbase_type&, + const erev_type&, + const tau_type&); /** * @brief Create an instance from a DOM element. @@ -24749,9 +28768,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - GapJunction (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + AlphaSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -24762,9 +28781,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GapJunction (const GapJunction& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + AlphaSynapse (const AlphaSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -24777,7 +28796,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GapJunction* + virtual AlphaSynapse* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -24789,8 +28808,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GapJunction& - operator= (const GapJunction& x); + AlphaSynapse& + operator= (const AlphaSynapse& x); //@} @@ -24798,7 +28817,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GapJunction (); + ~AlphaSynapse (); // Implementation. // @@ -24811,104 +28830,38 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< conductance_type > conductance_; + ::xsd::cxx::tree::one< tau_type > tau_; //@endcond }; bool - operator== (const GapJunction&, const GapJunction&); + operator== (const AlphaSynapse&, const AlphaSynapse&); bool - operator!= (const GapJunction&, const GapJunction&); - - - /** - * @brief Class corresponding to the %SilentSynapse schema type. - * - * Dummy synapse which emits no current. Used as presynaptic endpoint for - * analog synaptic connection. - * - * @nosubgrouping - */ - class SilentSynapse: public ::neuroml2::BaseSynapse - { - public: - /** - * @name Constructors - */ - //@{ - - /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. - */ - SilentSynapse (const id_type&); - - /** - * @brief Create an instance from a DOM element. - * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. - */ - SilentSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Copy constructor. - * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * - * For polymorphic object models use the @c _clone function instead. - */ - SilentSynapse (const SilentSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Copy the instance polymorphically. - * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. - * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. - */ - virtual SilentSynapse* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; - - //@} + operator!= (const AlphaSynapse&, const AlphaSynapse&); - /** - * @brief Destructor. - */ - virtual - ~SilentSynapse (); - }; /** - * @brief Class corresponding to the %LinearGradedSynapse schema type. + * @brief Class corresponding to the %ExpOneSynapse schema type. * - * Behaves just like a one way gap junction. - * @param conductance + * Ohmic synapse model whose conductance rises instantaneously by ( + * **gbase** * **weight** ) on receiving an event, and which decays + * exponentially to zero with time course **tauDecay** + * @param tauDecay Time course of decay + * @param gbase Baseline conductance, generally the maximum conductance + * following a single spike + * @param erev Reversal potential of the synapse * * @nosubgrouping */ - class LinearGradedSynapse: public ::neuroml2::BaseSynapse + class ExpOneSynapse: public ::neuroml2::BaseConductanceBasedSynapse { public: /** - * @name conductance + * @name tauDecay * - * @brief Accessor and modifier functions for the %conductance + * @brief Accessor and modifier functions for the %tauDecay * required attribute. */ //@{ @@ -24916,28 +28869,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductance conductance_type; + typedef ::neuroml2::Nml2Quantity_time tauDecay_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< conductance_type, char > conductance_traits; + typedef ::xsd::cxx::tree::traits< tauDecay_type, char > tauDecay_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const conductance_type& - conductance () const; + const tauDecay_type& + tauDecay () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - conductance_type& - conductance (); + tauDecay_type& + tauDecay (); /** * @brief Set the attribute value. @@ -24948,7 +28901,7 @@ namespace neuroml2 * the new value of the attribute. */ void - conductance (const conductance_type& x); + tauDecay (const tauDecay_type& x); /** * @brief Set the attribute value without copying. @@ -24959,7 +28912,7 @@ namespace neuroml2 * instead of making a copy. */ void - conductance (::std::unique_ptr< conductance_type > p); + tauDecay (::std::unique_ptr< tauDecay_type > p); //@} @@ -24972,8 +28925,10 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - LinearGradedSynapse (const id_type&, - const conductance_type&); + ExpOneSynapse (const id_type&, + const gbase_type&, + const erev_type&, + const tauDecay_type&); /** * @brief Create an instance from a DOM element. @@ -24983,9 +28938,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - LinearGradedSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + ExpOneSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -24996,9 +28951,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - LinearGradedSynapse (const LinearGradedSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + ExpOneSynapse (const ExpOneSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -25011,7 +28966,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual LinearGradedSynapse* + virtual ExpOneSynapse* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -25023,8 +28978,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - LinearGradedSynapse& - operator= (const LinearGradedSynapse& x); + ExpOneSynapse& + operator= (const ExpOneSynapse& x); //@} @@ -25032,7 +28987,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~LinearGradedSynapse (); + ~ExpOneSynapse (); // Implementation. // @@ -25045,212 +29000,40 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< conductance_type > conductance_; + ::xsd::cxx::tree::one< tauDecay_type > tauDecay_; //@endcond }; bool - operator== (const LinearGradedSynapse&, const LinearGradedSynapse&); + operator== (const ExpOneSynapse&, const ExpOneSynapse&); bool - operator!= (const LinearGradedSynapse&, const LinearGradedSynapse&); + operator!= (const ExpOneSynapse&, const ExpOneSynapse&); /** - * @brief Class corresponding to the %GradedSynapse schema type. + * @brief Class corresponding to the %ExpTwoSynapse schema type. * - * Graded/analog synapse. Based on synapse in Methods of http://www. - * nature.com/neuro/journal/v7/n12/abs/nn1352.html - * @param conductance - * @param delta Slope of the activation curve - * @param k Rate constant for transmitter-receptor dissociation rate - * @param Vth The half-activation voltage of the synapse - * @param erev The reversal potential of the synapse + * Ohmic synapse model whose conductance waveform on receiving an event + * has a rise time of **tauRise** and a decay time of **tauDecay.** Max + * conductance reached during this time ( assuming zero conductance + * before ) is **gbase** * **weight.** + * @param tauRise + * @param tauDecay + * @param gbase Baseline conductance, generally the maximum conductance + * following a single spike + * @param erev Reversal potential of the synapse * * @nosubgrouping */ - class GradedSynapse: public ::neuroml2::BaseSynapse + class ExpTwoSynapse: public ::neuroml2::BaseConductanceBasedSynapse { public: /** - * @name conductance - * - * @brief Accessor and modifier functions for the %conductance - * required attribute. - */ - //@{ - - /** - * @brief Attribute type. - */ - typedef ::neuroml2::Nml2Quantity_conductance conductance_type; - - /** - * @brief Attribute traits type. - */ - typedef ::xsd::cxx::tree::traits< conductance_type, char > conductance_traits; - - /** - * @brief Return a read-only (constant) reference to the attribute. - * - * @return A constant reference to the attribute. - */ - const conductance_type& - conductance () const; - - /** - * @brief Return a read-write reference to the attribute. - * - * @return A reference to the attribute. - */ - conductance_type& - conductance (); - - /** - * @brief Set the attribute value. - * - * @param x A new value to set. - * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. - */ - void - conductance (const conductance_type& x); - - /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. - */ - void - conductance (::std::unique_ptr< conductance_type > p); - - //@} - - /** - * @name delta - * - * @brief Accessor and modifier functions for the %delta - * required attribute. - */ - //@{ - - /** - * @brief Attribute type. - */ - typedef ::neuroml2::Nml2Quantity_voltage delta_type; - - /** - * @brief Attribute traits type. - */ - typedef ::xsd::cxx::tree::traits< delta_type, char > delta_traits; - - /** - * @brief Return a read-only (constant) reference to the attribute. - * - * @return A constant reference to the attribute. - */ - const delta_type& - delta () const; - - /** - * @brief Return a read-write reference to the attribute. - * - * @return A reference to the attribute. - */ - delta_type& - delta (); - - /** - * @brief Set the attribute value. - * - * @param x A new value to set. - * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. - */ - void - delta (const delta_type& x); - - /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. - */ - void - delta (::std::unique_ptr< delta_type > p); - - //@} - - /** - * @name Vth - * - * @brief Accessor and modifier functions for the %Vth - * required attribute. - */ - //@{ - - /** - * @brief Attribute type. - */ - typedef ::neuroml2::Nml2Quantity_voltage Vth_type; - - /** - * @brief Attribute traits type. - */ - typedef ::xsd::cxx::tree::traits< Vth_type, char > Vth_traits; - - /** - * @brief Return a read-only (constant) reference to the attribute. - * - * @return A constant reference to the attribute. - */ - const Vth_type& - Vth () const; - - /** - * @brief Return a read-write reference to the attribute. - * - * @return A reference to the attribute. - */ - Vth_type& - Vth (); - - /** - * @brief Set the attribute value. - * - * @param x A new value to set. - * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. - */ - void - Vth (const Vth_type& x); - - /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. - */ - void - Vth (::std::unique_ptr< Vth_type > p); - - //@} - - /** - * @name k + * @name tauDecay * - * @brief Accessor and modifier functions for the %k + * @brief Accessor and modifier functions for the %tauDecay * required attribute. */ //@{ @@ -25258,28 +29041,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_pertime k_type; + typedef ::neuroml2::Nml2Quantity_time tauDecay_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< k_type, char > k_traits; + typedef ::xsd::cxx::tree::traits< tauDecay_type, char > tauDecay_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const k_type& - k () const; + const tauDecay_type& + tauDecay () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - k_type& - k (); + tauDecay_type& + tauDecay (); /** * @brief Set the attribute value. @@ -25290,7 +29073,7 @@ namespace neuroml2 * the new value of the attribute. */ void - k (const k_type& x); + tauDecay (const tauDecay_type& x); /** * @brief Set the attribute value without copying. @@ -25301,14 +29084,14 @@ namespace neuroml2 * instead of making a copy. */ void - k (::std::unique_ptr< k_type > p); + tauDecay (::std::unique_ptr< tauDecay_type > p); //@} /** - * @name erev + * @name tauRise * - * @brief Accessor and modifier functions for the %erev + * @brief Accessor and modifier functions for the %tauRise * required attribute. */ //@{ @@ -25316,28 +29099,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage erev_type; + typedef ::neuroml2::Nml2Quantity_time tauRise_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< erev_type, char > erev_traits; + typedef ::xsd::cxx::tree::traits< tauRise_type, char > tauRise_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const erev_type& - erev () const; + const tauRise_type& + tauRise () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - erev_type& - erev (); + tauRise_type& + tauRise (); /** * @brief Set the attribute value. @@ -25348,7 +29131,7 @@ namespace neuroml2 * the new value of the attribute. */ void - erev (const erev_type& x); + tauRise (const tauRise_type& x); /** * @brief Set the attribute value without copying. @@ -25359,7 +29142,7 @@ namespace neuroml2 * instead of making a copy. */ void - erev (::std::unique_ptr< erev_type > p); + tauRise (::std::unique_ptr< tauRise_type > p); //@} @@ -25372,12 +29155,11 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - GradedSynapse (const id_type&, - const conductance_type&, - const delta_type&, - const Vth_type&, - const k_type&, - const erev_type&); + ExpTwoSynapse (const id_type&, + const gbase_type&, + const erev_type&, + const tauDecay_type&, + const tauRise_type&); /** * @brief Create an instance from a DOM element. @@ -25387,7 +29169,7 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - GradedSynapse (const ::xercesc::DOMElement& e, + ExpTwoSynapse (const ::xercesc::DOMElement& e, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -25400,7 +29182,7 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GradedSynapse (const GradedSynapse& x, + ExpTwoSynapse (const ExpTwoSynapse& x, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -25415,7 +29197,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual GradedSynapse* + virtual ExpTwoSynapse* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -25427,8 +29209,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - GradedSynapse& - operator= (const GradedSynapse& x); + ExpTwoSynapse& + operator= (const ExpTwoSynapse& x); //@} @@ -25436,7 +29218,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~GradedSynapse (); + ~ExpTwoSynapse (); // Implementation. // @@ -25449,38 +29231,41 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< conductance_type > conductance_; - ::xsd::cxx::tree::one< delta_type > delta_; - ::xsd::cxx::tree::one< Vth_type > Vth_; - ::xsd::cxx::tree::one< k_type > k_; - ::xsd::cxx::tree::one< erev_type > erev_; + ::xsd::cxx::tree::one< tauDecay_type > tauDecay_; + ::xsd::cxx::tree::one< tauRise_type > tauRise_; //@endcond }; bool - operator== (const GradedSynapse&, const GradedSynapse&); + operator== (const ExpTwoSynapse&, const ExpTwoSynapse&); bool - operator!= (const GradedSynapse&, const GradedSynapse&); + operator!= (const ExpTwoSynapse&, const ExpTwoSynapse&); /** - * @brief Class corresponding to the %AlphaCurrentSynapse schema type. + * @brief Class corresponding to the %ExpThreeSynapse schema type. * - * Alpha current synapse: rise time and decay time are both **tau.** - * @param tau Time course for rise and decay - * @param ibase Baseline current increase after receiving a spike + * Ohmic synapse similar to expTwoSynapse but consisting of two + * components that can differ in decay times and max conductances but + * share the same rise time. + * @param tauRise + * @param tauDecay1 + * @param tauDecay2 + * @param gbase1 Baseline conductance 1 + * @param gbase2 Baseline conductance 2 + * @param erev Reversal potential of the synapse * * @nosubgrouping */ - class AlphaCurrentSynapse: public ::neuroml2::BaseCurrentBasedSynapse + class ExpThreeSynapse: public ::neuroml2::BaseConductanceBasedSynapseTwo { public: /** - * @name tau + * @name tauDecay1 * - * @brief Accessor and modifier functions for the %tau + * @brief Accessor and modifier functions for the %tauDecay1 * required attribute. */ //@{ @@ -25488,28 +29273,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time tau_type; + typedef ::neuroml2::Nml2Quantity_time tauDecay1_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< tau_type, char > tau_traits; + typedef ::xsd::cxx::tree::traits< tauDecay1_type, char > tauDecay1_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const tau_type& - tau () const; + const tauDecay1_type& + tauDecay1 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - tau_type& - tau (); + tauDecay1_type& + tauDecay1 (); /** * @brief Set the attribute value. @@ -25520,7 +29305,7 @@ namespace neuroml2 * the new value of the attribute. */ void - tau (const tau_type& x); + tauDecay1 (const tauDecay1_type& x); /** * @brief Set the attribute value without copying. @@ -25531,14 +29316,14 @@ namespace neuroml2 * instead of making a copy. */ void - tau (::std::unique_ptr< tau_type > p); + tauDecay1 (::std::unique_ptr< tauDecay1_type > p); //@} /** - * @name ibase + * @name tauDecay2 * - * @brief Accessor and modifier functions for the %ibase + * @brief Accessor and modifier functions for the %tauDecay2 * required attribute. */ //@{ @@ -25546,28 +29331,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_current ibase_type; + typedef ::neuroml2::Nml2Quantity_time tauDecay2_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< ibase_type, char > ibase_traits; + typedef ::xsd::cxx::tree::traits< tauDecay2_type, char > tauDecay2_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const ibase_type& - ibase () const; + const tauDecay2_type& + tauDecay2 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - ibase_type& - ibase (); + tauDecay2_type& + tauDecay2 (); /** * @brief Set the attribute value. @@ -25578,7 +29363,7 @@ namespace neuroml2 * the new value of the attribute. */ void - ibase (const ibase_type& x); + tauDecay2 (const tauDecay2_type& x); /** * @brief Set the attribute value without copying. @@ -25589,126 +29374,14 @@ namespace neuroml2 * instead of making a copy. */ void - ibase (::std::unique_ptr< ibase_type > p); - - //@} - - /** - * @name Constructors - */ - //@{ - - /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. - */ - AlphaCurrentSynapse (const id_type&, - const tau_type&, - const ibase_type&); - - /** - * @brief Create an instance from a DOM element. - * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. - */ - AlphaCurrentSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Copy constructor. - * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * - * For polymorphic object models use the @c _clone function instead. - */ - AlphaCurrentSynapse (const AlphaCurrentSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Copy the instance polymorphically. - * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. - * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. - */ - virtual AlphaCurrentSynapse* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; - - /** - * @brief Copy assignment operator. - * - * @param x An instance to make a copy of. - * @return A reference to itself. - * - * For polymorphic object models use the @c _clone function instead. - */ - AlphaCurrentSynapse& - operator= (const AlphaCurrentSynapse& x); + tauDecay2 (::std::unique_ptr< tauDecay2_type > p); //@} /** - * @brief Destructor. - */ - virtual - ~AlphaCurrentSynapse (); - - // Implementation. - // - - //@cond - - protected: - void - parse (::xsd::cxx::xml::dom::parser< char >&, - ::xml_schema::flags); - - protected: - ::xsd::cxx::tree::one< tau_type > tau_; - ::xsd::cxx::tree::one< ibase_type > ibase_; - - //@endcond - }; - - bool - operator== (const AlphaCurrentSynapse&, const AlphaCurrentSynapse&); - - bool - operator!= (const AlphaCurrentSynapse&, const AlphaCurrentSynapse&); - - - /** - * @brief Class corresponding to the %AlphaSynapse schema type. - * - * Ohmic synapse model where rise time and decay time are both **tau.** - * Max conductance reached during this time ( assuming zero conductance - * before ) is **gbase** * **weight.** - * @param tau Time course of rise/decay - * @param gbase Baseline conductance, generally the maximum conductance - * following a single spike - * @param erev Reversal potential of the synapse - * - * @nosubgrouping - */ - class AlphaSynapse: public ::neuroml2::BaseConductanceBasedSynapse - { - public: - /** - * @name tau + * @name tauRise * - * @brief Accessor and modifier functions for the %tau + * @brief Accessor and modifier functions for the %tauRise * required attribute. */ //@{ @@ -25716,28 +29389,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time tau_type; + typedef ::neuroml2::Nml2Quantity_time tauRise_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< tau_type, char > tau_traits; + typedef ::xsd::cxx::tree::traits< tauRise_type, char > tauRise_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const tau_type& - tau () const; + const tauRise_type& + tauRise () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - tau_type& - tau (); + tauRise_type& + tauRise (); /** * @brief Set the attribute value. @@ -25748,7 +29421,7 @@ namespace neuroml2 * the new value of the attribute. */ void - tau (const tau_type& x); + tauRise (const tauRise_type& x); /** * @brief Set the attribute value without copying. @@ -25759,7 +29432,7 @@ namespace neuroml2 * instead of making a copy. */ void - tau (::std::unique_ptr< tau_type > p); + tauRise (::std::unique_ptr< tauRise_type > p); //@} @@ -25772,10 +29445,13 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - AlphaSynapse (const id_type&, - const gbase_type&, - const erev_type&, - const tau_type&); + ExpThreeSynapse (const id_type&, + const gbase1_type&, + const gbase2_type&, + const erev_type&, + const tauDecay1_type&, + const tauDecay2_type&, + const tauRise_type&); /** * @brief Create an instance from a DOM element. @@ -25785,9 +29461,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - AlphaSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + ExpThreeSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -25798,9 +29474,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - AlphaSynapse (const AlphaSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + ExpThreeSynapse (const ExpThreeSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -25813,7 +29489,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual AlphaSynapse* + virtual ExpThreeSynapse* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -25825,8 +29501,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - AlphaSynapse& - operator= (const AlphaSynapse& x); + ExpThreeSynapse& + operator= (const ExpThreeSynapse& x); //@} @@ -25834,7 +29510,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~AlphaSynapse (); + ~ExpThreeSynapse (); // Implementation. // @@ -25847,38 +29523,35 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< tau_type > tau_; + ::xsd::cxx::tree::one< tauDecay1_type > tauDecay1_; + ::xsd::cxx::tree::one< tauDecay2_type > tauDecay2_; + ::xsd::cxx::tree::one< tauRise_type > tauRise_; //@endcond }; bool - operator== (const AlphaSynapse&, const AlphaSynapse&); + operator== (const ExpThreeSynapse&, const ExpThreeSynapse&); bool - operator!= (const AlphaSynapse&, const AlphaSynapse&); + operator!= (const ExpThreeSynapse&, const ExpThreeSynapse&); /** - * @brief Class corresponding to the %ExpOneSynapse schema type. + * @brief Class corresponding to the %DoubleSynapse schema type. * - * Ohmic synapse model whose conductance rises instantaneously by ( - * **gbase** * **weight** ) on receiving an event, and which decays - * exponentially to zero with time course **tauDecay** - * @param tauDecay Time course of decay - * @param gbase Baseline conductance, generally the maximum conductance - * following a single spike - * @param erev Reversal potential of the synapse + * Synapse consisting of two independent synaptic mechanisms ( e. g. + * AMPA-R and NMDA-R ), which can be easily colocated in connections * * @nosubgrouping */ - class ExpOneSynapse: public ::neuroml2::BaseConductanceBasedSynapse + class DoubleSynapse: public ::neuroml2::BaseVoltageDepSynapse { public: /** - * @name tauDecay + * @name synapse1 * - * @brief Accessor and modifier functions for the %tauDecay + * @brief Accessor and modifier functions for the %synapse1 * required attribute. */ //@{ @@ -25886,28 +29559,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time tauDecay_type; + typedef ::neuroml2::NmlId synapse1_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< tauDecay_type, char > tauDecay_traits; + typedef ::xsd::cxx::tree::traits< synapse1_type, char > synapse1_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const tauDecay_type& - tauDecay () const; + const synapse1_type& + synapse1 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - tauDecay_type& - tauDecay (); + synapse1_type& + synapse1 (); /** * @brief Set the attribute value. @@ -25918,7 +29591,7 @@ namespace neuroml2 * the new value of the attribute. */ void - tauDecay (const tauDecay_type& x); + synapse1 (const synapse1_type& x); /** * @brief Set the attribute value without copying. @@ -25929,128 +29602,72 @@ namespace neuroml2 * instead of making a copy. */ void - tauDecay (::std::unique_ptr< tauDecay_type > p); + synapse1 (::std::unique_ptr< synapse1_type > p); //@} /** - * @name Constructors + * @name synapse2 + * + * @brief Accessor and modifier functions for the %synapse2 + * required attribute. */ //@{ /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Attribute type. */ - ExpOneSynapse (const id_type&, - const gbase_type&, - const erev_type&, - const tauDecay_type&); + typedef ::neuroml2::NmlId synapse2_type; /** - * @brief Create an instance from a DOM element. - * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @brief Attribute traits type. */ - ExpOneSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + typedef ::xsd::cxx::tree::traits< synapse2_type, char > synapse2_traits; /** - * @brief Copy constructor. - * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. + * @brief Return a read-only (constant) reference to the attribute. * - * For polymorphic object models use the @c _clone function instead. + * @return A constant reference to the attribute. */ - ExpOneSynapse (const ExpOneSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + const synapse2_type& + synapse2 () const; /** - * @brief Copy the instance polymorphically. - * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. + * @brief Return a read-write reference to the attribute. * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. + * @return A reference to the attribute. */ - virtual ExpOneSynapse* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; + synapse2_type& + synapse2 (); /** - * @brief Copy assignment operator. + * @brief Set the attribute value. * - * @param x An instance to make a copy of. - * @return A reference to itself. + * @param x A new value to set. * - * For polymorphic object models use the @c _clone function instead. + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - ExpOneSynapse& - operator= (const ExpOneSynapse& x); - - //@} + void + synapse2 (const synapse2_type& x); /** - * @brief Destructor. + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. */ - virtual - ~ExpOneSynapse (); - - // Implementation. - // - - //@cond - - protected: void - parse (::xsd::cxx::xml::dom::parser< char >&, - ::xml_schema::flags); - - protected: - ::xsd::cxx::tree::one< tauDecay_type > tauDecay_; - - //@endcond - }; - - bool - operator== (const ExpOneSynapse&, const ExpOneSynapse&); - - bool - operator!= (const ExpOneSynapse&, const ExpOneSynapse&); + synapse2 (::std::unique_ptr< synapse2_type > p); + //@} - /** - * @brief Class corresponding to the %ExpTwoSynapse schema type. - * - * Ohmic synapse model whose conductance waveform on receiving an event - * has a rise time of **tauRise** and a decay time of **tauDecay.** Max - * conductance reached during this time ( assuming zero conductance - * before ) is **gbase** * **weight.** - * @param tauRise - * @param tauDecay - * @param gbase Baseline conductance, generally the maximum conductance - * following a single spike - * @param erev Reversal potential of the synapse - * - * @nosubgrouping - */ - class ExpTwoSynapse: public ::neuroml2::BaseConductanceBasedSynapse - { - public: /** - * @name tauDecay + * @name synapse1Path * - * @brief Accessor and modifier functions for the %tauDecay + * @brief Accessor and modifier functions for the %synapse1Path * required attribute. */ //@{ @@ -26058,28 +29675,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time tauDecay_type; + typedef ::xml_schema::string synapse1Path_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< tauDecay_type, char > tauDecay_traits; + typedef ::xsd::cxx::tree::traits< synapse1Path_type, char > synapse1Path_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const tauDecay_type& - tauDecay () const; + const synapse1Path_type& + synapse1Path () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - tauDecay_type& - tauDecay (); + synapse1Path_type& + synapse1Path (); /** * @brief Set the attribute value. @@ -26090,7 +29707,7 @@ namespace neuroml2 * the new value of the attribute. */ void - tauDecay (const tauDecay_type& x); + synapse1Path (const synapse1Path_type& x); /** * @brief Set the attribute value without copying. @@ -26101,14 +29718,14 @@ namespace neuroml2 * instead of making a copy. */ void - tauDecay (::std::unique_ptr< tauDecay_type > p); + synapse1Path (::std::unique_ptr< synapse1Path_type > p); //@} /** - * @name tauRise + * @name synapse2Path * - * @brief Accessor and modifier functions for the %tauRise + * @brief Accessor and modifier functions for the %synapse2Path * required attribute. */ //@{ @@ -26116,28 +29733,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time tauRise_type; + typedef ::xml_schema::string synapse2Path_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< tauRise_type, char > tauRise_traits; + typedef ::xsd::cxx::tree::traits< synapse2Path_type, char > synapse2Path_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const tauRise_type& - tauRise () const; + const synapse2Path_type& + synapse2Path () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - tauRise_type& - tauRise (); + synapse2Path_type& + synapse2Path (); /** * @brief Set the attribute value. @@ -26148,7 +29765,7 @@ namespace neuroml2 * the new value of the attribute. */ void - tauRise (const tauRise_type& x); + synapse2Path (const synapse2Path_type& x); /** * @brief Set the attribute value without copying. @@ -26159,7 +29776,7 @@ namespace neuroml2 * instead of making a copy. */ void - tauRise (::std::unique_ptr< tauRise_type > p); + synapse2Path (::std::unique_ptr< synapse2Path_type > p); //@} @@ -26172,11 +29789,11 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - ExpTwoSynapse (const id_type&, - const gbase_type&, - const erev_type&, - const tauDecay_type&, - const tauRise_type&); + DoubleSynapse (const id_type&, + const synapse1_type&, + const synapse2_type&, + const synapse1Path_type&, + const synapse2Path_type&); /** * @brief Create an instance from a DOM element. @@ -26186,7 +29803,7 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - ExpTwoSynapse (const ::xercesc::DOMElement& e, + DoubleSynapse (const ::xercesc::DOMElement& e, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -26199,7 +29816,7 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - ExpTwoSynapse (const ExpTwoSynapse& x, + DoubleSynapse (const DoubleSynapse& x, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -26214,7 +29831,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual ExpTwoSynapse* + virtual DoubleSynapse* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -26226,8 +29843,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - ExpTwoSynapse& - operator= (const ExpTwoSynapse& x); + DoubleSynapse& + operator= (const DoubleSynapse& x); //@} @@ -26235,7 +29852,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~ExpTwoSynapse (); + ~DoubleSynapse (); // Implementation. // @@ -26248,208 +29865,186 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< tauDecay_type > tauDecay_; - ::xsd::cxx::tree::one< tauRise_type > tauRise_; + ::xsd::cxx::tree::one< synapse1_type > synapse1_; + ::xsd::cxx::tree::one< synapse2_type > synapse2_; + ::xsd::cxx::tree::one< synapse1Path_type > synapse1Path_; + ::xsd::cxx::tree::one< synapse2Path_type > synapse2Path_; //@endcond }; bool - operator== (const ExpTwoSynapse&, const ExpTwoSynapse&); + operator== (const DoubleSynapse&, const DoubleSynapse&); bool - operator!= (const ExpTwoSynapse&, const ExpTwoSynapse&); + operator!= (const DoubleSynapse&, const DoubleSynapse&); /** - * @brief Class corresponding to the %ExpThreeSynapse schema type. + * @brief Class corresponding to the %BlockingPlasticSynapse schema type. * - * Ohmic synapse similar to expTwoSynapse but consisting of two - * components that can differ in decay times and max conductances but - * share the same rise time. + * Biexponential synapse that allows for optional block and plasticity + * mechanisms, which can be expressed as child elements. * @param tauRise - * @param tauDecay1 - * @param tauDecay2 - * @param gbase1 Baseline conductance 1 - * @param gbase2 Baseline conductance 2 + * @param tauDecay + * @param gbase Baseline conductance, generally the maximum conductance + * following a single spike * @param erev Reversal potential of the synapse * * @nosubgrouping - */ - class ExpThreeSynapse: public ::neuroml2::BaseConductanceBasedSynapseTwo - { - public: - /** - * @name tauDecay1 - * - * @brief Accessor and modifier functions for the %tauDecay1 - * required attribute. - */ - //@{ - - /** - * @brief Attribute type. - */ - typedef ::neuroml2::Nml2Quantity_time tauDecay1_type; - - /** - * @brief Attribute traits type. - */ - typedef ::xsd::cxx::tree::traits< tauDecay1_type, char > tauDecay1_traits; - - /** - * @brief Return a read-only (constant) reference to the attribute. - * - * @return A constant reference to the attribute. - */ - const tauDecay1_type& - tauDecay1 () const; - - /** - * @brief Return a read-write reference to the attribute. - * - * @return A reference to the attribute. - */ - tauDecay1_type& - tauDecay1 (); - - /** - * @brief Set the attribute value. - * - * @param x A new value to set. - * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. - */ - void - tauDecay1 (const tauDecay1_type& x); - + */ + class BlockingPlasticSynapse: public ::neuroml2::ExpTwoSynapse + { + public: /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. + * @name plasticityMechanism * - * This function will try to use the passed value directly - * instead of making a copy. + * @brief Accessor and modifier functions for the %plasticityMechanism + * optional element. */ - void - tauDecay1 (::std::unique_ptr< tauDecay1_type > p); - - //@} + //@{ /** - * @name tauDecay2 - * - * @brief Accessor and modifier functions for the %tauDecay2 - * required attribute. + * @brief Element type. */ - //@{ + typedef ::neuroml2::PlasticityMechanism plasticityMechanism_type; /** - * @brief Attribute type. + * @brief Element optional container type. */ - typedef ::neuroml2::Nml2Quantity_time tauDecay2_type; + typedef ::xsd::cxx::tree::optional< plasticityMechanism_type > plasticityMechanism_optional; /** - * @brief Attribute traits type. + * @brief Element traits type. */ - typedef ::xsd::cxx::tree::traits< tauDecay2_type, char > tauDecay2_traits; + typedef ::xsd::cxx::tree::traits< plasticityMechanism_type, char > plasticityMechanism_traits; /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Return a read-only (constant) reference to the element + * container. * - * @return A constant reference to the attribute. + * @return A constant reference to the optional container. */ - const tauDecay2_type& - tauDecay2 () const; + const plasticityMechanism_optional& + plasticityMechanism () const; /** - * @brief Return a read-write reference to the attribute. + * @brief Return a read-write reference to the element container. * - * @return A reference to the attribute. + * @return A reference to the optional container. */ - tauDecay2_type& - tauDecay2 (); + plasticityMechanism_optional& + plasticityMechanism (); /** - * @brief Set the attribute value. + * @brief Set the element value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * the new value of the element. */ void - tauDecay2 (const tauDecay2_type& x); + plasticityMechanism (const plasticityMechanism_type& x); /** - * @brief Set the attribute value without copying. + * @brief Set the element value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. + */ + void + plasticityMechanism (const plasticityMechanism_optional& x); + + /** + * @brief Set the element value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - tauDecay2 (::std::unique_ptr< tauDecay2_type > p); + plasticityMechanism (::std::unique_ptr< plasticityMechanism_type > p); //@} /** - * @name tauRise + * @name blockMechanism * - * @brief Accessor and modifier functions for the %tauRise - * required attribute. + * @brief Accessor and modifier functions for the %blockMechanism + * optional element. */ //@{ /** - * @brief Attribute type. + * @brief Element type. */ - typedef ::neuroml2::Nml2Quantity_time tauRise_type; + typedef ::neuroml2::BlockMechanism blockMechanism_type; /** - * @brief Attribute traits type. + * @brief Element optional container type. */ - typedef ::xsd::cxx::tree::traits< tauRise_type, char > tauRise_traits; + typedef ::xsd::cxx::tree::optional< blockMechanism_type > blockMechanism_optional; /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Element traits type. + */ + typedef ::xsd::cxx::tree::traits< blockMechanism_type, char > blockMechanism_traits; + + /** + * @brief Return a read-only (constant) reference to the element + * container. * - * @return A constant reference to the attribute. + * @return A constant reference to the optional container. */ - const tauRise_type& - tauRise () const; + const blockMechanism_optional& + blockMechanism () const; /** - * @brief Return a read-write reference to the attribute. + * @brief Return a read-write reference to the element container. * - * @return A reference to the attribute. + * @return A reference to the optional container. */ - tauRise_type& - tauRise (); + blockMechanism_optional& + blockMechanism (); /** - * @brief Set the attribute value. + * @brief Set the element value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * the new value of the element. */ void - tauRise (const tauRise_type& x); + blockMechanism (const blockMechanism_type& x); /** - * @brief Set the attribute value without copying. + * @brief Set the element value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the element. + * Otherwise the element container is set the 'not present' state. + */ + void + blockMechanism (const blockMechanism_optional& x); + + /** + * @brief Set the element value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - tauRise (::std::unique_ptr< tauRise_type > p); + blockMechanism (::std::unique_ptr< blockMechanism_type > p); //@} @@ -26462,13 +30057,11 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - ExpThreeSynapse (const id_type&, - const gbase1_type&, - const gbase2_type&, - const erev_type&, - const tauDecay1_type&, - const tauDecay2_type&, - const tauRise_type&); + BlockingPlasticSynapse (const id_type&, + const gbase_type&, + const erev_type&, + const tauDecay_type&, + const tauRise_type&); /** * @brief Create an instance from a DOM element. @@ -26478,9 +30071,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - ExpThreeSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + BlockingPlasticSynapse (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -26491,9 +30084,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - ExpThreeSynapse (const ExpThreeSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + BlockingPlasticSynapse (const BlockingPlasticSynapse& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -26506,7 +30099,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual ExpThreeSynapse* + virtual BlockingPlasticSynapse* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -26518,8 +30111,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - ExpThreeSynapse& - operator= (const ExpThreeSynapse& x); + BlockingPlasticSynapse& + operator= (const BlockingPlasticSynapse& x); //@} @@ -26527,7 +30120,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~ExpThreeSynapse (); + ~BlockingPlasticSynapse (); // Implementation. // @@ -26540,151 +30133,175 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< tauDecay1_type > tauDecay1_; - ::xsd::cxx::tree::one< tauDecay2_type > tauDecay2_; - ::xsd::cxx::tree::one< tauRise_type > tauRise_; + plasticityMechanism_optional plasticityMechanism_; + blockMechanism_optional blockMechanism_; //@endcond }; bool - operator== (const ExpThreeSynapse&, const ExpThreeSynapse&); + operator== (const BlockingPlasticSynapse&, const BlockingPlasticSynapse&); bool - operator!= (const ExpThreeSynapse&, const ExpThreeSynapse&); + operator!= (const BlockingPlasticSynapse&, const BlockingPlasticSynapse&); /** - * @brief Class corresponding to the %DoubleSynapse schema type. - * - * Synapse consisting of two independent synaptic mechanisms ( e. g. - * AMPA-R and NMDA-R ), which can be easily colocated in connections - * - * @nosubgrouping + * @brief Enumeration class corresponding to the %BlockTypes + * schema type. */ - class DoubleSynapse: public ::neuroml2::BaseVoltageDepSynapse + class BlockTypes: public ::xml_schema::string { public: - /** - * @name synapse1 - * - * @brief Accessor and modifier functions for the %synapse1 - * required attribute. - */ - //@{ - - /** - * @brief Attribute type. - */ - typedef ::neuroml2::NmlId synapse1_type; /** - * @brief Attribute traits type. + * @brief Underlying enum type. */ - typedef ::xsd::cxx::tree::traits< synapse1_type, char > synapse1_traits; + enum value + { + voltageConcDepBlockMechanism + }; /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Create an instance from the underlying enum value. * - * @return A constant reference to the attribute. + * @param v A enum value. */ - const synapse1_type& - synapse1 () const; + BlockTypes (value v); /** - * @brief Return a read-write reference to the attribute. + * @brief Create an instance from a C string. * - * @return A reference to the attribute. + * @param v A string value. */ - synapse1_type& - synapse1 (); + BlockTypes (const char* v); /** - * @brief Set the attribute value. - * - * @param x A new value to set. + * @brief Create an instance from a string. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * @param v A string value. */ - void - synapse1 (const synapse1_type& x); + BlockTypes (const ::std::string& v); /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. + * @brief Create an instance from the base value. * - * This function will try to use the passed value directly - * instead of making a copy. + * @param v A base value. */ - void - synapse1 (::std::unique_ptr< synapse1_type > p); - - //@} + BlockTypes (const ::xml_schema::string& v); /** - * @name synapse2 + * @brief Create an instance from a DOM element. * - * @brief Accessor and modifier functions for the %synapse2 - * required attribute. + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - //@{ + BlockTypes (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Attribute type. + * @brief Create an instance from a DOM attribute. + * + * @param a A DOM attribute to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - typedef ::neuroml2::NmlId synapse2_type; + BlockTypes (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Attribute traits type. + * @brief Create an instance from a string fragment. + * + * @param s A string fragment to extract the data from. + * @param e A pointer to DOM element containing the string fragment. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - typedef ::xsd::cxx::tree::traits< synapse2_type, char > synapse2_traits; + BlockTypes (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Copy constructor. * - * @return A constant reference to the attribute. + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. */ - const synapse2_type& - synapse2 () const; + BlockTypes (const BlockTypes& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-write reference to the attribute. + * @brief Copy the instance polymorphically. * - * @return A reference to the attribute. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - synapse2_type& - synapse2 (); + virtual BlockTypes* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; /** - * @brief Set the attribute value. - * - * @param x A new value to set. + * @brief Assign the underlying enum value. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * @param v A enum value. + * @return A refernce to the instance. */ - void - synapse2 (const synapse2_type& x); + BlockTypes& + operator= (value v); /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. + * @brief Implicit conversion operator to the underlying + * enum value. * - * This function will try to use the passed value directly - * instead of making a copy. + * @return A enum value. */ - void - synapse2 (::std::unique_ptr< synapse2_type > p); + virtual + operator value () const + { + return _xsd_BlockTypes_convert (); + } - //@} + //@cond + protected: + value + _xsd_BlockTypes_convert () const; + + public: + static const char* const _xsd_BlockTypes_literals_[1]; + static const value _xsd_BlockTypes_indexes_[1]; + + //@endcond + }; + + /** + * @brief Class corresponding to the %BlockMechanism schema type. + * + * @nosubgrouping + */ + class BlockMechanism: public ::neuroml2::BaseWithoutId + { + public: /** - * @name synapse1Path + * @name type * - * @brief Accessor and modifier functions for the %synapse1Path + * @brief Accessor and modifier functions for the %type * required attribute. */ //@{ @@ -26692,28 +30309,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::xml_schema::string synapse1Path_type; + typedef ::neuroml2::BlockTypes type_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< synapse1Path_type, char > synapse1Path_traits; + typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const synapse1Path_type& - synapse1Path () const; + const type_type& + type () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - synapse1Path_type& - synapse1Path (); + type_type& + type (); /** * @brief Set the attribute value. @@ -26724,7 +30341,7 @@ namespace neuroml2 * the new value of the attribute. */ void - synapse1Path (const synapse1Path_type& x); + type (const type_type& x); /** * @brief Set the attribute value without copying. @@ -26735,14 +30352,14 @@ namespace neuroml2 * instead of making a copy. */ void - synapse1Path (::std::unique_ptr< synapse1Path_type > p); + type (::std::unique_ptr< type_type > p); //@} /** - * @name synapse2Path + * @name species * - * @brief Accessor and modifier functions for the %synapse2Path + * @brief Accessor and modifier functions for the %species * required attribute. */ //@{ @@ -26750,28 +30367,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::xml_schema::string synapse2Path_type; + typedef ::neuroml2::NmlId species_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< synapse2Path_type, char > synapse2Path_traits; + typedef ::xsd::cxx::tree::traits< species_type, char > species_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const synapse2Path_type& - synapse2Path () const; + const species_type& + species () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - synapse2Path_type& - synapse2Path (); + species_type& + species (); /** * @brief Set the attribute value. @@ -26782,7 +30399,7 @@ namespace neuroml2 * the new value of the attribute. */ void - synapse2Path (const synapse2Path_type& x); + species (const species_type& x); /** * @brief Set the attribute value without copying. @@ -26793,275 +30410,181 @@ namespace neuroml2 * instead of making a copy. */ void - synapse2Path (::std::unique_ptr< synapse2Path_type > p); + species (::std::unique_ptr< species_type > p); //@} /** - * @name Constructors + * @name blockConcentration + * + * @brief Accessor and modifier functions for the %blockConcentration + * required attribute. */ //@{ /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Attribute type. */ - DoubleSynapse (const id_type&, - const synapse1_type&, - const synapse2_type&, - const synapse1Path_type&, - const synapse2Path_type&); + typedef ::neuroml2::Nml2Quantity_concentration blockConcentration_type; /** - * @brief Create an instance from a DOM element. - * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @brief Attribute traits type. */ - DoubleSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + typedef ::xsd::cxx::tree::traits< blockConcentration_type, char > blockConcentration_traits; /** - * @brief Copy constructor. - * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. + * @brief Return a read-only (constant) reference to the attribute. * - * For polymorphic object models use the @c _clone function instead. + * @return A constant reference to the attribute. */ - DoubleSynapse (const DoubleSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + const blockConcentration_type& + blockConcentration () const; /** - * @brief Copy the instance polymorphically. - * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. + * @brief Return a read-write reference to the attribute. * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. + * @return A reference to the attribute. */ - virtual DoubleSynapse* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; + blockConcentration_type& + blockConcentration (); /** - * @brief Copy assignment operator. + * @brief Set the attribute value. * - * @param x An instance to make a copy of. - * @return A reference to itself. + * @param x A new value to set. * - * For polymorphic object models use the @c _clone function instead. - */ - DoubleSynapse& - operator= (const DoubleSynapse& x); - - //@} - - /** - * @brief Destructor. + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - virtual - ~DoubleSynapse (); - - // Implementation. - // - - //@cond - - protected: void - parse (::xsd::cxx::xml::dom::parser< char >&, - ::xml_schema::flags); - - protected: - ::xsd::cxx::tree::one< synapse1_type > synapse1_; - ::xsd::cxx::tree::one< synapse2_type > synapse2_; - ::xsd::cxx::tree::one< synapse1Path_type > synapse1Path_; - ::xsd::cxx::tree::one< synapse2Path_type > synapse2Path_; - - //@endcond - }; - - bool - operator== (const DoubleSynapse&, const DoubleSynapse&); - - bool - operator!= (const DoubleSynapse&, const DoubleSynapse&); - + blockConcentration (const blockConcentration_type& x); - /** - * @brief Class corresponding to the %BlockingPlasticSynapse schema type. - * - * Biexponential synapse that allows for optional block and plasticity - * mechanisms, which can be expressed as child elements. - * @param tauRise - * @param tauDecay - * @param gbase Baseline conductance, generally the maximum conductance - * following a single spike - * @param erev Reversal potential of the synapse - * - * @nosubgrouping - */ - class BlockingPlasticSynapse: public ::neuroml2::ExpTwoSynapse - { - public: /** - * @name plasticityMechanism + * @brief Set the attribute value without copying. * - * @brief Accessor and modifier functions for the %plasticityMechanism - * optional element. + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. */ - //@{ + void + blockConcentration (::std::unique_ptr< blockConcentration_type > p); + + //@} /** - * @brief Element type. + * @name scalingConc + * + * @brief Accessor and modifier functions for the %scalingConc + * required attribute. */ - typedef ::neuroml2::PlasticityMechanism plasticityMechanism_type; + //@{ /** - * @brief Element optional container type. + * @brief Attribute type. */ - typedef ::xsd::cxx::tree::optional< plasticityMechanism_type > plasticityMechanism_optional; + typedef ::neuroml2::Nml2Quantity_concentration scalingConc_type; /** - * @brief Element traits type. + * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< plasticityMechanism_type, char > plasticityMechanism_traits; + typedef ::xsd::cxx::tree::traits< scalingConc_type, char > scalingConc_traits; /** - * @brief Return a read-only (constant) reference to the element - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const plasticityMechanism_optional& - plasticityMechanism () const; + const scalingConc_type& + scalingConc () const; /** - * @brief Return a read-write reference to the element container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - plasticityMechanism_optional& - plasticityMechanism (); + scalingConc_type& + scalingConc (); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the element. - */ - void - plasticityMechanism (const plasticityMechanism_type& x); - - /** - * @brief Set the element value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. + * the new value of the attribute. */ void - plasticityMechanism (const plasticityMechanism_optional& x); + scalingConc (const scalingConc_type& x); /** - * @brief Set the element value without copying. + * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - plasticityMechanism (::std::unique_ptr< plasticityMechanism_type > p); + scalingConc (::std::unique_ptr< scalingConc_type > p); //@} /** - * @name blockMechanism + * @name scalingVolt * - * @brief Accessor and modifier functions for the %blockMechanism - * optional element. + * @brief Accessor and modifier functions for the %scalingVolt + * required attribute. */ //@{ /** - * @brief Element type. - */ - typedef ::neuroml2::BlockMechanism blockMechanism_type; - - /** - * @brief Element optional container type. + * @brief Attribute type. */ - typedef ::xsd::cxx::tree::optional< blockMechanism_type > blockMechanism_optional; + typedef ::neuroml2::Nml2Quantity_voltage scalingVolt_type; /** - * @brief Element traits type. + * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< blockMechanism_type, char > blockMechanism_traits; + typedef ::xsd::cxx::tree::traits< scalingVolt_type, char > scalingVolt_traits; /** - * @brief Return a read-only (constant) reference to the element - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const blockMechanism_optional& - blockMechanism () const; + const scalingVolt_type& + scalingVolt () const; /** - * @brief Return a read-write reference to the element container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - blockMechanism_optional& - blockMechanism (); + scalingVolt_type& + scalingVolt (); /** - * @brief Set the element value. + * @brief Set the attribute value. * * @param x A new value to set. * * This function makes a copy of its argument and sets it as - * the new value of the element. - */ - void - blockMechanism (const blockMechanism_type& x); - - /** - * @brief Set the element value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the element. - * Otherwise the element container is set the 'not present' state. + * the new value of the attribute. */ void - blockMechanism (const blockMechanism_optional& x); + scalingVolt (const scalingVolt_type& x); /** - * @brief Set the element value without copying. + * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - blockMechanism (::std::unique_ptr< blockMechanism_type > p); + scalingVolt (::std::unique_ptr< scalingVolt_type > p); //@} @@ -27074,11 +30597,11 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - BlockingPlasticSynapse (const id_type&, - const gbase_type&, - const erev_type&, - const tauDecay_type&, - const tauRise_type&); + BlockMechanism (const type_type&, + const species_type&, + const blockConcentration_type&, + const scalingConc_type&, + const scalingVolt_type&); /** * @brief Create an instance from a DOM element. @@ -27088,9 +30611,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - BlockingPlasticSynapse (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + BlockMechanism (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -27101,9 +30624,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BlockingPlasticSynapse (const BlockingPlasticSynapse& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + BlockMechanism (const BlockMechanism& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -27116,7 +30639,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual BlockingPlasticSynapse* + virtual BlockMechanism* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -27128,8 +30651,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BlockingPlasticSynapse& - operator= (const BlockingPlasticSynapse& x); + BlockMechanism& + operator= (const BlockMechanism& x); //@} @@ -27137,7 +30660,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~BlockingPlasticSynapse (); + ~BlockMechanism (); // Implementation. // @@ -27150,24 +30673,27 @@ namespace neuroml2 ::xml_schema::flags); protected: - plasticityMechanism_optional plasticityMechanism_; - blockMechanism_optional blockMechanism_; + ::xsd::cxx::tree::one< type_type > type_; + ::xsd::cxx::tree::one< species_type > species_; + ::xsd::cxx::tree::one< blockConcentration_type > blockConcentration_; + ::xsd::cxx::tree::one< scalingConc_type > scalingConc_; + ::xsd::cxx::tree::one< scalingVolt_type > scalingVolt_; //@endcond }; bool - operator== (const BlockingPlasticSynapse&, const BlockingPlasticSynapse&); + operator== (const BlockMechanism&, const BlockMechanism&); bool - operator!= (const BlockingPlasticSynapse&, const BlockingPlasticSynapse&); + operator!= (const BlockMechanism&, const BlockMechanism&); /** - * @brief Enumeration class corresponding to the %BlockTypes + * @brief Enumeration class corresponding to the %PlasticityTypes * schema type. */ - class BlockTypes: public ::xml_schema::string + class PlasticityTypes: public ::xml_schema::string { public: @@ -27176,7 +30702,8 @@ namespace neuroml2 */ enum value { - voltageConcDepBlockMechanism + tsodyksMarkramDepMechanism, + tsodyksMarkramDepFacMechanism }; /** @@ -27184,28 +30711,28 @@ namespace neuroml2 * * @param v A enum value. */ - BlockTypes (value v); + PlasticityTypes (value v); /** * @brief Create an instance from a C string. * * @param v A string value. */ - BlockTypes (const char* v); + PlasticityTypes (const char* v); /** * @brief Create an instance from a string. * * @param v A string value. */ - BlockTypes (const ::std::string& v); + PlasticityTypes (const ::std::string& v); /** * @brief Create an instance from the base value. * * @param v A base value. */ - BlockTypes (const ::xml_schema::string& v); + PlasticityTypes (const ::xml_schema::string& v); /** * @brief Create an instance from a DOM element. @@ -27215,9 +30742,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - BlockTypes (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + PlasticityTypes (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Create an instance from a DOM attribute. @@ -27227,9 +30754,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - BlockTypes (const ::xercesc::DOMAttr& a, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + PlasticityTypes (const ::xercesc::DOMAttr& a, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Create an instance from a string fragment. @@ -27240,10 +30767,10 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - BlockTypes (const ::std::string& s, - const ::xercesc::DOMElement* e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + PlasticityTypes (const ::std::string& s, + const ::xercesc::DOMElement* e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -27254,9 +30781,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BlockTypes (const BlockTypes& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + PlasticityTypes (const PlasticityTypes& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -27269,7 +30796,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual BlockTypes* + virtual PlasticityTypes* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -27279,7 +30806,7 @@ namespace neuroml2 * @param v A enum value. * @return A refernce to the instance. */ - BlockTypes& + PlasticityTypes& operator= (value v); /** @@ -27291,27 +30818,28 @@ namespace neuroml2 virtual operator value () const { - return _xsd_BlockTypes_convert (); + return _xsd_PlasticityTypes_convert (); } //@cond protected: value - _xsd_BlockTypes_convert () const; + _xsd_PlasticityTypes_convert () const; public: - static const char* const _xsd_BlockTypes_literals_[1]; - static const value _xsd_BlockTypes_indexes_[1]; + static const char* const _xsd_PlasticityTypes_literals_[2]; + static const value _xsd_PlasticityTypes_indexes_[2]; //@endcond }; /** - * @brief Class corresponding to the %BlockMechanism schema type. + * @brief Class corresponding to the %PlasticityMechanism schema type. * * @nosubgrouping */ + class PlasticityMechanism: public ::neuroml2::BaseWithoutId { public: /** @@ -27325,7 +30853,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::BlockTypes type_type; + typedef ::neuroml2::PlasticityTypes type_type; /** * @brief Attribute traits type. @@ -27373,9 +30901,9 @@ namespace neuroml2 //@} /** - * @name species + * @name initReleaseProb * - * @brief Accessor and modifier functions for the %species + * @brief Accessor and modifier functions for the %initReleaseProb * required attribute. */ //@{ @@ -27383,28 +30911,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::NmlId species_type; + typedef ::neuroml2::ZeroToOne initReleaseProb_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< species_type, char > species_traits; + typedef ::xsd::cxx::tree::traits< initReleaseProb_type, char > initReleaseProb_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const species_type& - species () const; + const initReleaseProb_type& + initReleaseProb () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - species_type& - species (); + initReleaseProb_type& + initReleaseProb (); /** * @brief Set the attribute value. @@ -27415,7 +30943,7 @@ namespace neuroml2 * the new value of the attribute. */ void - species (const species_type& x); + initReleaseProb (const initReleaseProb_type& x); /** * @brief Set the attribute value without copying. @@ -27426,14 +30954,14 @@ namespace neuroml2 * instead of making a copy. */ void - species (::std::unique_ptr< species_type > p); + initReleaseProb (::std::unique_ptr< initReleaseProb_type > p); //@} /** - * @name blockConcentration + * @name tauRec * - * @brief Accessor and modifier functions for the %blockConcentration + * @brief Accessor and modifier functions for the %tauRec * required attribute. */ //@{ @@ -27441,28 +30969,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_concentration blockConcentration_type; + typedef ::neuroml2::Nml2Quantity_time tauRec_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< blockConcentration_type, char > blockConcentration_traits; + typedef ::xsd::cxx::tree::traits< tauRec_type, char > tauRec_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const blockConcentration_type& - blockConcentration () const; + const tauRec_type& + tauRec () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - blockConcentration_type& - blockConcentration (); + tauRec_type& + tauRec (); /** * @brief Set the attribute value. @@ -27473,7 +31001,7 @@ namespace neuroml2 * the new value of the attribute. */ void - blockConcentration (const blockConcentration_type& x); + tauRec (const tauRec_type& x); /** * @brief Set the attribute value without copying. @@ -27484,43 +31012,49 @@ namespace neuroml2 * instead of making a copy. */ void - blockConcentration (::std::unique_ptr< blockConcentration_type > p); + tauRec (::std::unique_ptr< tauRec_type > p); //@} /** - * @name scalingConc + * @name tauFac * - * @brief Accessor and modifier functions for the %scalingConc - * required attribute. + * @brief Accessor and modifier functions for the %tauFac + * optional attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_concentration scalingConc_type; + typedef ::neuroml2::Nml2Quantity_time tauFac_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< tauFac_type > tauFac_optional; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< scalingConc_type, char > scalingConc_traits; + typedef ::xsd::cxx::tree::traits< tauFac_type, char > tauFac_traits; /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Return a read-only (constant) reference to the attribute + * container. * - * @return A constant reference to the attribute. + * @return A constant reference to the optional container. */ - const scalingConc_type& - scalingConc () const; + const tauFac_optional& + tauFac () const; /** - * @brief Return a read-write reference to the attribute. + * @brief Return a read-write reference to the attribute container. * - * @return A reference to the attribute. + * @return A reference to the optional container. */ - scalingConc_type& - scalingConc (); + tauFac_optional& + tauFac (); /** * @brief Set the attribute value. @@ -27531,76 +31065,30 @@ namespace neuroml2 * the new value of the attribute. */ void - scalingConc (const scalingConc_type& x); - - /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. - */ - void - scalingConc (::std::unique_ptr< scalingConc_type > p); - - //@} - - /** - * @name scalingVolt - * - * @brief Accessor and modifier functions for the %scalingVolt - * required attribute. - */ - //@{ - - /** - * @brief Attribute type. - */ - typedef ::neuroml2::Nml2Quantity_voltage scalingVolt_type; - - /** - * @brief Attribute traits type. - */ - typedef ::xsd::cxx::tree::traits< scalingVolt_type, char > scalingVolt_traits; - - /** - * @brief Return a read-only (constant) reference to the attribute. - * - * @return A constant reference to the attribute. - */ - const scalingVolt_type& - scalingVolt () const; - - /** - * @brief Return a read-write reference to the attribute. - * - * @return A reference to the attribute. - */ - scalingVolt_type& - scalingVolt (); + tauFac (const tauFac_type& x); /** * @brief Set the attribute value. * - * @param x A new value to set. + * @param x An optional container with the new value to set. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. */ void - scalingVolt (const scalingVolt_type& x); + tauFac (const tauFac_optional& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly - * instead of making a copy. + * This function will try to use the passed value directly instead + * of making a copy. */ void - scalingVolt (::std::unique_ptr< scalingVolt_type > p); + tauFac (::std::unique_ptr< tauFac_type > p); //@} @@ -27613,11 +31101,9 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - BlockMechanism (const type_type&, - const species_type&, - const blockConcentration_type&, - const scalingConc_type&, - const scalingVolt_type&); + PlasticityMechanism (const type_type&, + const initReleaseProb_type&, + const tauRec_type&); /** * @brief Create an instance from a DOM element. @@ -27627,9 +31113,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - BlockMechanism (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + PlasticityMechanism (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -27640,9 +31126,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BlockMechanism (const BlockMechanism& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + PlasticityMechanism (const PlasticityMechanism& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -27655,7 +31141,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual BlockMechanism* + virtual PlasticityMechanism* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -27667,8 +31153,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BlockMechanism& - operator= (const BlockMechanism& x); + PlasticityMechanism& + operator= (const PlasticityMechanism& x); //@} @@ -27676,7 +31162,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~BlockMechanism (); + ~PlasticityMechanism (); // Implementation. // @@ -27690,103 +31176,130 @@ namespace neuroml2 protected: ::xsd::cxx::tree::one< type_type > type_; - ::xsd::cxx::tree::one< species_type > species_; - ::xsd::cxx::tree::one< blockConcentration_type > blockConcentration_; - ::xsd::cxx::tree::one< scalingConc_type > scalingConc_; - ::xsd::cxx::tree::one< scalingVolt_type > scalingVolt_; + ::xsd::cxx::tree::one< initReleaseProb_type > initReleaseProb_; + ::xsd::cxx::tree::one< tauRec_type > tauRec_; + tauFac_optional tauFac_; //@endcond }; bool - operator== (const BlockMechanism&, const BlockMechanism&); + operator== (const PlasticityMechanism&, const PlasticityMechanism&); bool - operator!= (const BlockMechanism&, const BlockMechanism&); + operator!= (const PlasticityMechanism&, const PlasticityMechanism&); /** - * @brief Enumeration class corresponding to the %PlasticityTypes - * schema type. + * @brief Class corresponding to the %BaseCell schema type. + * + * Base type of any cell ( e. g. point neuron like + * **izhikevich2007Cell** , or a morphologically detailed **Cell** with + * **segment** s ) which can be used in a **population** + * + * @nosubgrouping */ - class PlasticityTypes: public ::xml_schema::string + class BaseCell: public ::neuroml2::Standalone { public: + /** + * @name neuroLexId + * + * @brief Accessor and modifier functions for the %neuroLexId + * optional attribute. + */ + //@{ /** - * @brief Underlying enum type. + * @brief Attribute type. */ - enum value - { - tsodyksMarkramDepMechanism, - tsodyksMarkramDepFacMechanism - }; + typedef ::neuroml2::NeuroLexId neuroLexId_type; /** - * @brief Create an instance from the underlying enum value. - * - * @param v A enum value. + * @brief Attribute optional container type. */ - PlasticityTypes (value v); + typedef ::xsd::cxx::tree::optional< neuroLexId_type > neuroLexId_optional; /** - * @brief Create an instance from a C string. - * - * @param v A string value. + * @brief Attribute traits type. */ - PlasticityTypes (const char* v); + typedef ::xsd::cxx::tree::traits< neuroLexId_type, char > neuroLexId_traits; /** - * @brief Create an instance from a string. + * @brief Return a read-only (constant) reference to the attribute + * container. * - * @param v A string value. + * @return A constant reference to the optional container. */ - PlasticityTypes (const ::std::string& v); + const neuroLexId_optional& + neuroLexId () const; /** - * @brief Create an instance from the base value. + * @brief Return a read-write reference to the attribute container. * - * @param v A base value. + * @return A reference to the optional container. */ - PlasticityTypes (const ::xml_schema::string& v); + neuroLexId_optional& + neuroLexId (); /** - * @brief Create an instance from a DOM element. + * @brief Set the attribute value. * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - PlasticityTypes (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + void + neuroLexId (const neuroLexId_type& x); /** - * @brief Create an instance from a DOM attribute. + * @brief Set the attribute value. * - * @param a A DOM attribute to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. */ - PlasticityTypes (const ::xercesc::DOMAttr& a, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + void + neuroLexId (const neuroLexId_optional& x); /** - * @brief Create an instance from a string fragment. + * @brief Set the attribute value without copying. * - * @param s A string fragment to extract the data from. - * @param e A pointer to DOM element containing the string fragment. + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + neuroLexId (::std::unique_ptr< neuroLexId_type > p); + + //@} + + /** + * @name Constructors + */ + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + BaseCell (const id_type&); + + /** + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. * @param f Flags to create the new instance with. * @param c A pointer to the object that will contain the new * instance. */ - PlasticityTypes (const ::std::string& s, - const ::xercesc::DOMElement* e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + BaseCell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -27797,9 +31310,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - PlasticityTypes (const PlasticityTypes& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + BaseCell (const BaseCell& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -27812,55 +31325,72 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual PlasticityTypes* + virtual BaseCell* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; /** - * @brief Assign the underlying enum value. + * @brief Copy assignment operator. * - * @param v A enum value. - * @return A refernce to the instance. + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. */ - PlasticityTypes& - operator= (value v); + BaseCell& + operator= (const BaseCell& x); + + //@} /** - * @brief Implicit conversion operator to the underlying - * enum value. - * - * @return A enum value. + * @brief Destructor. */ - virtual - operator value () const - { - return _xsd_PlasticityTypes_convert (); - } + virtual + ~BaseCell (); + + // Implementation. + // //@cond protected: - value - _xsd_PlasticityTypes_convert () const; + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); - public: - static const char* const _xsd_PlasticityTypes_literals_[2]; - static const value _xsd_PlasticityTypes_indexes_[2]; + protected: + neuroLexId_optional neuroLexId_; //@endcond }; + bool + operator== (const BaseCell&, const BaseCell&); + + bool + operator!= (const BaseCell&, const BaseCell&); + + /** - * @brief Class corresponding to the %PlasticityMechanism schema type. + * @brief Class corresponding to the %IafTauCell schema type. + * + * Integrate and fire cell which returns to its leak reversal potential + * of **leakReversal** with a time constant **tau** + * @param leakReversal + * @param tau + * @param thresh The membrane potential at which to emit a spiking event + * and reset voltage + * @param reset The value the membrane potential is reset to on spiking * * @nosubgrouping */ + class IafTauCell: public ::neuroml2::BaseCell { public: /** - * @name type + * @name leakReversal * - * @brief Accessor and modifier functions for the %type + * @brief Accessor and modifier functions for the %leakReversal * required attribute. */ //@{ @@ -27868,28 +31398,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::PlasticityTypes type_type; + typedef ::neuroml2::Nml2Quantity_voltage leakReversal_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< type_type, char > type_traits; + typedef ::xsd::cxx::tree::traits< leakReversal_type, char > leakReversal_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const type_type& - type () const; + const leakReversal_type& + leakReversal () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - type_type& - type (); + leakReversal_type& + leakReversal (); /** * @brief Set the attribute value. @@ -27900,7 +31430,7 @@ namespace neuroml2 * the new value of the attribute. */ void - type (const type_type& x); + leakReversal (const leakReversal_type& x); /** * @brief Set the attribute value without copying. @@ -27911,14 +31441,14 @@ namespace neuroml2 * instead of making a copy. */ void - type (::std::unique_ptr< type_type > p); + leakReversal (::std::unique_ptr< leakReversal_type > p); //@} /** - * @name initReleaseProb + * @name thresh * - * @brief Accessor and modifier functions for the %initReleaseProb + * @brief Accessor and modifier functions for the %thresh * required attribute. */ //@{ @@ -27926,28 +31456,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::ZeroToOne initReleaseProb_type; + typedef ::neuroml2::Nml2Quantity_voltage thresh_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< initReleaseProb_type, char > initReleaseProb_traits; + typedef ::xsd::cxx::tree::traits< thresh_type, char > thresh_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const initReleaseProb_type& - initReleaseProb () const; + const thresh_type& + thresh () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - initReleaseProb_type& - initReleaseProb (); + thresh_type& + thresh (); /** * @brief Set the attribute value. @@ -27958,7 +31488,7 @@ namespace neuroml2 * the new value of the attribute. */ void - initReleaseProb (const initReleaseProb_type& x); + thresh (const thresh_type& x); /** * @brief Set the attribute value without copying. @@ -27969,14 +31499,14 @@ namespace neuroml2 * instead of making a copy. */ void - initReleaseProb (::std::unique_ptr< initReleaseProb_type > p); + thresh (::std::unique_ptr< thresh_type > p); //@} /** - * @name tauRec + * @name reset * - * @brief Accessor and modifier functions for the %tauRec + * @brief Accessor and modifier functions for the %reset * required attribute. */ //@{ @@ -27984,28 +31514,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time tauRec_type; + typedef ::neuroml2::Nml2Quantity_voltage reset_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< tauRec_type, char > tauRec_traits; + typedef ::xsd::cxx::tree::traits< reset_type, char > reset_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const tauRec_type& - tauRec () const; + const reset_type& + reset () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - tauRec_type& - tauRec (); + reset_type& + reset (); /** * @brief Set the attribute value. @@ -28016,7 +31546,7 @@ namespace neuroml2 * the new value of the attribute. */ void - tauRec (const tauRec_type& x); + reset (const reset_type& x); /** * @brief Set the attribute value without copying. @@ -28027,49 +31557,43 @@ namespace neuroml2 * instead of making a copy. */ void - tauRec (::std::unique_ptr< tauRec_type > p); + reset (::std::unique_ptr< reset_type > p); //@} /** - * @name tauFac + * @name tau * - * @brief Accessor and modifier functions for the %tauFac - * optional attribute. + * @brief Accessor and modifier functions for the %tau + * required attribute. */ //@{ /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time tauFac_type; - - /** - * @brief Attribute optional container type. - */ - typedef ::xsd::cxx::tree::optional< tauFac_type > tauFac_optional; + typedef ::neuroml2::Nml2Quantity_time tau_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< tauFac_type, char > tauFac_traits; + typedef ::xsd::cxx::tree::traits< tau_type, char > tau_traits; /** - * @brief Return a read-only (constant) reference to the attribute - * container. + * @brief Return a read-only (constant) reference to the attribute. * - * @return A constant reference to the optional container. + * @return A constant reference to the attribute. */ - const tauFac_optional& - tauFac () const; + const tau_type& + tau () const; /** - * @brief Return a read-write reference to the attribute container. + * @brief Return a read-write reference to the attribute. * - * @return A reference to the optional container. + * @return A reference to the attribute. */ - tauFac_optional& - tauFac (); + tau_type& + tau (); /** * @brief Set the attribute value. @@ -28080,30 +31604,18 @@ namespace neuroml2 * the new value of the attribute. */ void - tauFac (const tauFac_type& x); - - /** - * @brief Set the attribute value. - * - * @param x An optional container with the new value to set. - * - * If the value is present in @a x then this function makes a copy - * of this value and sets it as the new value of the attribute. - * Otherwise the attribute container is set the 'not present' state. - */ - void - tauFac (const tauFac_optional& x); + tau (const tau_type& x); /** * @brief Set the attribute value without copying. * * @param p A new value to use. * - * This function will try to use the passed value directly instead - * of making a copy. + * This function will try to use the passed value directly + * instead of making a copy. */ void - tauFac (::std::unique_ptr< tauFac_type > p); + tau (::std::unique_ptr< tau_type > p); //@} @@ -28116,9 +31628,11 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - PlasticityMechanism (const type_type&, - const initReleaseProb_type&, - const tauRec_type&); + IafTauCell (const id_type&, + const leakReversal_type&, + const thresh_type&, + const reset_type&, + const tau_type&); /** * @brief Create an instance from a DOM element. @@ -28128,9 +31642,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - PlasticityMechanism (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IafTauCell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -28141,9 +31655,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - PlasticityMechanism (const PlasticityMechanism& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IafTauCell (const IafTauCell& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -28156,7 +31670,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual PlasticityMechanism* + virtual IafTauCell* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -28168,8 +31682,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - PlasticityMechanism& - operator= (const PlasticityMechanism& x); + IafTauCell& + operator= (const IafTauCell& x); //@} @@ -28177,7 +31691,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~PlasticityMechanism (); + ~IafTauCell (); // Implementation. // @@ -28190,33 +31704,97 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< type_type > type_; - ::xsd::cxx::tree::one< initReleaseProb_type > initReleaseProb_; - ::xsd::cxx::tree::one< tauRec_type > tauRec_; - tauFac_optional tauFac_; + ::xsd::cxx::tree::one< leakReversal_type > leakReversal_; + ::xsd::cxx::tree::one< thresh_type > thresh_; + ::xsd::cxx::tree::one< reset_type > reset_; + ::xsd::cxx::tree::one< tau_type > tau_; //@endcond }; bool - operator== (const PlasticityMechanism&, const PlasticityMechanism&); + operator== (const IafTauCell&, const IafTauCell&); bool - operator!= (const PlasticityMechanism&, const PlasticityMechanism&); + operator!= (const IafTauCell&, const IafTauCell&); /** - * @brief Class corresponding to the %BaseCell schema type. + * @brief Class corresponding to the %IafTauRefCell schema type. * - * Base type of any cell ( e. g. point neuron like - * **izhikevich2007Cell** , or a morphologically detailed **Cell** with - * **segment** s ) which can be used in a **population** + * Integrate and fire cell which returns to its leak reversal potential + * of **leakReversal** with a time course **tau.** It has a refractory + * period of **refract** after spiking + * @param refract + * @param leakReversal + * @param tau + * @param thresh The membrane potential at which to emit a spiking event + * and reset voltage + * @param reset The value the membrane potential is reset to on spiking * * @nosubgrouping */ - class BaseCell: public ::neuroml2::Standalone + class IafTauRefCell: public ::neuroml2::IafTauCell { public: + /** + * @name refract + * + * @brief Accessor and modifier functions for the %refract + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::Nml2Quantity_time refract_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< refract_type, char > refract_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const refract_type& + refract () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + refract_type& + refract (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + refract (const refract_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + refract (::std::unique_ptr< refract_type > p); + + //@} + /** * @name Constructors */ @@ -28226,7 +31804,12 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - BaseCell (const id_type&); + IafTauRefCell (const id_type&, + const leakReversal_type&, + const thresh_type&, + const reset_type&, + const tau_type&, + const refract_type&); /** * @brief Create an instance from a DOM element. @@ -28236,9 +31819,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - BaseCell (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IafTauRefCell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -28249,9 +31832,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - BaseCell (const BaseCell& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IafTauRefCell (const IafTauRefCell& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -28264,33 +31847,66 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual BaseCell* + virtual IafTauRefCell* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; + /** + * @brief Copy assignment operator. + * + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. + */ + IafTauRefCell& + operator= (const IafTauRefCell& x); + //@} /** * @brief Destructor. */ virtual - ~BaseCell (); + ~IafTauRefCell (); + + // Implementation. + // + + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< refract_type > refract_; + + //@endcond }; + bool + operator== (const IafTauRefCell&, const IafTauRefCell&); + + bool + operator!= (const IafTauRefCell&, const IafTauRefCell&); + + /** - * @brief Class corresponding to the %IafTauCell schema type. + * @brief Class corresponding to the %IafCell schema type. * - * Integrate and fire cell which returns to its leak reversal potential - * of **leakReversal** with a time constant **tau** + * Integrate and fire cell with capacitance **C,** **leakConductance** + * and **leakReversal** + * @param leakConductance * @param leakReversal - * @param tau - * @param thresh The membrane potential at which to emit a spiking event - * and reset voltage - * @param reset The value the membrane potential is reset to on spiking + * @param thresh + * @param reset + * @param C Total capacitance of the cell membrane * * @nosubgrouping */ - class IafTauCell: public ::neuroml2::BaseCell + class IafCell: public ::neuroml2::BaseCell { public: /** @@ -28468,9 +32084,9 @@ namespace neuroml2 //@} /** - * @name tau + * @name C * - * @brief Accessor and modifier functions for the %tau + * @brief Accessor and modifier functions for the %C * required attribute. */ //@{ @@ -28478,28 +32094,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time tau_type; + typedef ::neuroml2::Nml2Quantity_capacitance C_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< tau_type, char > tau_traits; + typedef ::xsd::cxx::tree::traits< C_type, char > C_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const tau_type& - tau () const; + const C_type& + C () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - tau_type& - tau (); + C_type& + C (); /** * @brief Set the attribute value. @@ -28510,7 +32126,7 @@ namespace neuroml2 * the new value of the attribute. */ void - tau (const tau_type& x); + C (const C_type& x); /** * @brief Set the attribute value without copying. @@ -28521,7 +32137,65 @@ namespace neuroml2 * instead of making a copy. */ void - tau (::std::unique_ptr< tau_type > p); + C (::std::unique_ptr< C_type > p); + + //@} + + /** + * @name leakConductance + * + * @brief Accessor and modifier functions for the %leakConductance + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::Nml2Quantity_conductance leakConductance_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< leakConductance_type, char > leakConductance_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const leakConductance_type& + leakConductance () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + leakConductance_type& + leakConductance (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + leakConductance (const leakConductance_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + leakConductance (::std::unique_ptr< leakConductance_type > p); //@} @@ -28534,11 +32208,12 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - IafTauCell (const id_type&, - const leakReversal_type&, - const thresh_type&, - const reset_type&, - const tau_type&); + IafCell (const id_type&, + const leakReversal_type&, + const thresh_type&, + const reset_type&, + const C_type&, + const leakConductance_type&); /** * @brief Create an instance from a DOM element. @@ -28548,9 +32223,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - IafTauCell (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IafCell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -28561,9 +32236,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IafTauCell (const IafTauCell& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IafCell (const IafCell& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -28576,7 +32251,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual IafTauCell* + virtual IafCell* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -28588,8 +32263,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IafTauCell& - operator= (const IafTauCell& x); + IafCell& + operator= (const IafCell& x); //@} @@ -28597,7 +32272,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~IafTauCell (); + ~IafCell (); // Implementation. // @@ -28613,34 +32288,34 @@ namespace neuroml2 ::xsd::cxx::tree::one< leakReversal_type > leakReversal_; ::xsd::cxx::tree::one< thresh_type > thresh_; ::xsd::cxx::tree::one< reset_type > reset_; - ::xsd::cxx::tree::one< tau_type > tau_; + ::xsd::cxx::tree::one< C_type > C_; + ::xsd::cxx::tree::one< leakConductance_type > leakConductance_; //@endcond }; bool - operator== (const IafTauCell&, const IafTauCell&); + operator== (const IafCell&, const IafCell&); bool - operator!= (const IafTauCell&, const IafTauCell&); + operator!= (const IafCell&, const IafCell&); /** - * @brief Class corresponding to the %IafTauRefCell schema type. + * @brief Class corresponding to the %IafRefCell schema type. * - * Integrate and fire cell which returns to its leak reversal potential - * of **leakReversal** with a time course **tau.** It has a refractory - * period of **refract** after spiking + * Integrate and fire cell with capacitance **C,** **leakConductance,** + * **leakReversal** and refractory period **refract** * @param refract + * @param leakConductance * @param leakReversal - * @param tau - * @param thresh The membrane potential at which to emit a spiking event - * and reset voltage - * @param reset The value the membrane potential is reset to on spiking + * @param thresh + * @param reset + * @param C Total capacitance of the cell membrane * * @nosubgrouping */ - class IafTauRefCell: public ::neuroml2::IafTauCell + class IafRefCell: public ::neuroml2::IafCell { public: /** @@ -28710,12 +32385,13 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - IafTauRefCell (const id_type&, - const leakReversal_type&, - const thresh_type&, - const reset_type&, - const tau_type&, - const refract_type&); + IafRefCell (const id_type&, + const leakReversal_type&, + const thresh_type&, + const reset_type&, + const C_type&, + const leakConductance_type&, + const refract_type&); /** * @brief Create an instance from a DOM element. @@ -28725,9 +32401,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - IafTauRefCell (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IafRefCell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -28738,9 +32414,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IafTauRefCell (const IafTauRefCell& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IafRefCell (const IafRefCell& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -28753,7 +32429,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual IafTauRefCell* + virtual IafRefCell* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -28765,8 +32441,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IafTauRefCell& - operator= (const IafTauRefCell& x); + IafRefCell& + operator= (const IafRefCell& x); //@} @@ -28774,7 +32450,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~IafTauRefCell (); + ~IafRefCell (); // Implementation. // @@ -28793,32 +32469,34 @@ namespace neuroml2 }; bool - operator== (const IafTauRefCell&, const IafTauRefCell&); + operator== (const IafRefCell&, const IafRefCell&); bool - operator!= (const IafTauRefCell&, const IafTauRefCell&); + operator!= (const IafRefCell&, const IafRefCell&); /** - * @brief Class corresponding to the %IafCell schema type. + * @brief Class corresponding to the %IzhikevichCell schema type. * - * Integrate and fire cell with capacitance **C,** **leakConductance** - * and **leakReversal** - * @param leakConductance - * @param leakReversal - * @param thresh - * @param reset - * @param C Total capacitance of the cell membrane + * Cell based on the 2003 model of Izhikevich, see + * http://izhikevich.org/publications/spikes.htm + * @param v0 Initial membrane potential + * @param a Time scale of the recovery variable U + * @param b Sensitivity of U to the subthreshold fluctuations of the + * membrane potential V + * @param c After-spike reset value of V + * @param d After-spike increase to U + * @param thresh Spike threshold * * @nosubgrouping */ - class IafCell: public ::neuroml2::BaseCell + class IzhikevichCell: public ::neuroml2::BaseCell { public: /** - * @name leakReversal + * @name v0 * - * @brief Accessor and modifier functions for the %leakReversal + * @brief Accessor and modifier functions for the %v0 * required attribute. */ //@{ @@ -28826,28 +32504,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage leakReversal_type; + typedef ::neuroml2::Nml2Quantity_voltage v0_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< leakReversal_type, char > leakReversal_traits; + typedef ::xsd::cxx::tree::traits< v0_type, char > v0_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const leakReversal_type& - leakReversal () const; + const v0_type& + v0 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - leakReversal_type& - leakReversal (); + v0_type& + v0 (); /** * @brief Set the attribute value. @@ -28858,7 +32536,7 @@ namespace neuroml2 * the new value of the attribute. */ void - leakReversal (const leakReversal_type& x); + v0 (const v0_type& x); /** * @brief Set the attribute value without copying. @@ -28869,7 +32547,7 @@ namespace neuroml2 * instead of making a copy. */ void - leakReversal (::std::unique_ptr< leakReversal_type > p); + v0 (::std::unique_ptr< v0_type > p); //@} @@ -28932,9 +32610,9 @@ namespace neuroml2 //@} /** - * @name reset + * @name a * - * @brief Accessor and modifier functions for the %reset + * @brief Accessor and modifier functions for the %a * required attribute. */ //@{ @@ -28942,28 +32620,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage reset_type; + typedef ::neuroml2::Nml2Quantity_none a_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< reset_type, char > reset_traits; + typedef ::xsd::cxx::tree::traits< a_type, char > a_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const reset_type& - reset () const; + const a_type& + a () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - reset_type& - reset (); + a_type& + a (); /** * @brief Set the attribute value. @@ -28974,7 +32652,7 @@ namespace neuroml2 * the new value of the attribute. */ void - reset (const reset_type& x); + a (const a_type& x); /** * @brief Set the attribute value without copying. @@ -28985,14 +32663,14 @@ namespace neuroml2 * instead of making a copy. */ void - reset (::std::unique_ptr< reset_type > p); + a (::std::unique_ptr< a_type > p); //@} /** - * @name C + * @name b * - * @brief Accessor and modifier functions for the %C + * @brief Accessor and modifier functions for the %b * required attribute. */ //@{ @@ -29000,28 +32678,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_capacitance C_type; + typedef ::neuroml2::Nml2Quantity_none b_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< C_type, char > C_traits; + typedef ::xsd::cxx::tree::traits< b_type, char > b_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const C_type& - C () const; + const b_type& + b () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - C_type& - C (); + b_type& + b (); /** * @brief Set the attribute value. @@ -29032,7 +32710,7 @@ namespace neuroml2 * the new value of the attribute. */ void - C (const C_type& x); + b (const b_type& x); /** * @brief Set the attribute value without copying. @@ -29043,14 +32721,14 @@ namespace neuroml2 * instead of making a copy. */ void - C (::std::unique_ptr< C_type > p); + b (::std::unique_ptr< b_type > p); //@} /** - * @name leakConductance + * @name c * - * @brief Accessor and modifier functions for the %leakConductance + * @brief Accessor and modifier functions for the %c * required attribute. */ //@{ @@ -29058,28 +32736,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductance leakConductance_type; + typedef ::neuroml2::Nml2Quantity_none c_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< leakConductance_type, char > leakConductance_traits; + typedef ::xsd::cxx::tree::traits< c_type, char > c_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const leakConductance_type& - leakConductance () const; + const c_type& + c () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - leakConductance_type& - leakConductance (); + c_type& + c (); /** * @brief Set the attribute value. @@ -29090,7 +32768,7 @@ namespace neuroml2 * the new value of the attribute. */ void - leakConductance (const leakConductance_type& x); + c (const c_type& x); /** * @brief Set the attribute value without copying. @@ -29101,7 +32779,65 @@ namespace neuroml2 * instead of making a copy. */ void - leakConductance (::std::unique_ptr< leakConductance_type > p); + c (::std::unique_ptr< c_type > p); + + //@} + + /** + * @name d + * + * @brief Accessor and modifier functions for the %d + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::Nml2Quantity_none d_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< d_type, char > d_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const d_type& + d () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + d_type& + d (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + d (const d_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + d (::std::unique_ptr< d_type > p); //@} @@ -29114,12 +32850,13 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - IafCell (const id_type&, - const leakReversal_type&, - const thresh_type&, - const reset_type&, - const C_type&, - const leakConductance_type&); + IzhikevichCell (const id_type&, + const v0_type&, + const thresh_type&, + const a_type&, + const b_type&, + const c_type&, + const d_type&); /** * @brief Create an instance from a DOM element. @@ -29129,9 +32866,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - IafCell (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IzhikevichCell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -29142,9 +32879,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IafCell (const IafCell& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + IzhikevichCell (const IzhikevichCell& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -29157,7 +32894,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual IafCell* + virtual IzhikevichCell* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -29169,8 +32906,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IafCell& - operator= (const IafCell& x); + IzhikevichCell& + operator= (const IzhikevichCell& x); //@} @@ -29178,7 +32915,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~IafCell (); + ~IzhikevichCell (); // Implementation. // @@ -29191,43 +32928,41 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< leakReversal_type > leakReversal_; + ::xsd::cxx::tree::one< v0_type > v0_; ::xsd::cxx::tree::one< thresh_type > thresh_; - ::xsd::cxx::tree::one< reset_type > reset_; - ::xsd::cxx::tree::one< C_type > C_; - ::xsd::cxx::tree::one< leakConductance_type > leakConductance_; + ::xsd::cxx::tree::one< a_type > a_; + ::xsd::cxx::tree::one< b_type > b_; + ::xsd::cxx::tree::one< c_type > c_; + ::xsd::cxx::tree::one< d_type > d_; //@endcond }; bool - operator== (const IafCell&, const IafCell&); + operator== (const IzhikevichCell&, const IzhikevichCell&); bool - operator!= (const IafCell&, const IafCell&); + operator!= (const IzhikevichCell&, const IzhikevichCell&); /** - * @brief Class corresponding to the %IafRefCell schema type. + * @brief Class corresponding to the %BaseCellMembPotCap schema type. * - * Integrate and fire cell with capacitance **C,** **leakConductance,** - * **leakReversal** and refractory period **refract** - * @param refract - * @param leakConductance - * @param leakReversal - * @param thresh - * @param reset + * Any cell with a membrane potential **v** with voltage units and a + * membrane capacitance **C.** Also defines exposed value **iSyn** for + * current due to external synapses and **iMemb** for total + * transmembrane current ( usually channel currents plus **iSyn** ) * @param C Total capacitance of the cell membrane * * @nosubgrouping */ - class IafRefCell: public ::neuroml2::IafCell + class BaseCellMembPotCap: public ::neuroml2::BaseCell { public: /** - * @name refract + * @name C * - * @brief Accessor and modifier functions for the %refract + * @brief Accessor and modifier functions for the %C * required attribute. */ //@{ @@ -29235,28 +32970,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time refract_type; + typedef ::neuroml2::Nml2Quantity_capacitance C_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< refract_type, char > refract_traits; + typedef ::xsd::cxx::tree::traits< C_type, char > C_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const refract_type& - refract () const; + const C_type& + C () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - refract_type& - refract (); + C_type& + C (); /** * @brief Set the attribute value. @@ -29267,7 +33002,7 @@ namespace neuroml2 * the new value of the attribute. */ void - refract (const refract_type& x); + C (const C_type& x); /** * @brief Set the attribute value without copying. @@ -29278,7 +33013,7 @@ namespace neuroml2 * instead of making a copy. */ void - refract (::std::unique_ptr< refract_type > p); + C (::std::unique_ptr< C_type > p); //@} @@ -29291,13 +33026,8 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - IafRefCell (const id_type&, - const leakReversal_type&, - const thresh_type&, - const reset_type&, - const C_type&, - const leakConductance_type&, - const refract_type&); + BaseCellMembPotCap (const id_type&, + const C_type&); /** * @brief Create an instance from a DOM element. @@ -29307,9 +33037,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - IafRefCell (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + BaseCellMembPotCap (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -29320,9 +33050,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IafRefCell (const IafRefCell& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + BaseCellMembPotCap (const BaseCellMembPotCap& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -29335,7 +33065,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual IafRefCell* + virtual BaseCellMembPotCap* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -29347,8 +33077,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IafRefCell& - operator= (const IafRefCell& x); + BaseCellMembPotCap& + operator= (const BaseCellMembPotCap& x); //@} @@ -29356,7 +33086,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~IafRefCell (); + ~BaseCellMembPotCap (); // Implementation. // @@ -29369,34 +33099,38 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< refract_type > refract_; + ::xsd::cxx::tree::one< C_type > C_; //@endcond }; bool - operator== (const IafRefCell&, const IafRefCell&); + operator== (const BaseCellMembPotCap&, const BaseCellMembPotCap&); bool - operator!= (const IafRefCell&, const IafRefCell&); + operator!= (const BaseCellMembPotCap&, const BaseCellMembPotCap&); /** - * @brief Class corresponding to the %IzhikevichCell schema type. + * @brief Class corresponding to the %Izhikevich2007Cell schema type. * - * Cell based on the 2003 model of Izhikevich, see - * http://izhikevich.org/publications/spikes.htm + * Cell based on the modified Izhikevich model in Izhikevich 2007, + * Dynamical systems in neuroscience, MIT Press * @param v0 Initial membrane potential - * @param a Time scale of the recovery variable U - * @param b Sensitivity of U to the subthreshold fluctuations of the - * membrane potential V - * @param c After-spike reset value of V - * @param d After-spike increase to U - * @param thresh Spike threshold + * @param k + * @param vr Resting membrane potential + * @param vt Spike threshold + * @param vpeak Peak action potential value + * @param a Time scale of recovery variable u + * @param b Sensitivity of recovery variable u to subthreshold + * fluctuations of membrane potential v + * @param c After-spike reset value of v + * @param d After-spike increase to u + * @param C Total capacitance of the cell membrane * * @nosubgrouping */ - class IzhikevichCell: public ::neuroml2::BaseCell + class Izhikevich2007Cell: public ::neuroml2::BaseCellMembPotCap { public: /** @@ -29458,9 +33192,9 @@ namespace neuroml2 //@} /** - * @name thresh + * @name k * - * @brief Accessor and modifier functions for the %thresh + * @brief Accessor and modifier functions for the %k * required attribute. */ //@{ @@ -29468,28 +33202,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage thresh_type; + typedef ::neuroml2::Nml2Quantity_conductancePerVoltage k_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< thresh_type, char > thresh_traits; + typedef ::xsd::cxx::tree::traits< k_type, char > k_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const thresh_type& - thresh () const; + const k_type& + k () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - thresh_type& - thresh (); + k_type& + k (); /** * @brief Set the attribute value. @@ -29500,7 +33234,7 @@ namespace neuroml2 * the new value of the attribute. */ void - thresh (const thresh_type& x); + k (const k_type& x); /** * @brief Set the attribute value without copying. @@ -29511,7 +33245,181 @@ namespace neuroml2 * instead of making a copy. */ void - thresh (::std::unique_ptr< thresh_type > p); + k (::std::unique_ptr< k_type > p); + + //@} + + /** + * @name vr + * + * @brief Accessor and modifier functions for the %vr + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::Nml2Quantity_voltage vr_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< vr_type, char > vr_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const vr_type& + vr () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + vr_type& + vr (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + vr (const vr_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + vr (::std::unique_ptr< vr_type > p); + + //@} + + /** + * @name vt + * + * @brief Accessor and modifier functions for the %vt + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::Nml2Quantity_voltage vt_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< vt_type, char > vt_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const vt_type& + vt () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + vt_type& + vt (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + vt (const vt_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + vt (::std::unique_ptr< vt_type > p); + + //@} + + /** + * @name vpeak + * + * @brief Accessor and modifier functions for the %vpeak + * required attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::Nml2Quantity_voltage vpeak_type; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< vpeak_type, char > vpeak_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const vpeak_type& + vpeak () const; + + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + vpeak_type& + vpeak (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + vpeak (const vpeak_type& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + vpeak (::std::unique_ptr< vpeak_type > p); //@} @@ -29526,7 +33434,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none a_type; + typedef ::neuroml2::Nml2Quantity_pertime a_type; /** * @brief Attribute traits type. @@ -29584,7 +33492,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none b_type; + typedef ::neuroml2::Nml2Quantity_conductance b_type; /** * @brief Attribute traits type. @@ -29642,7 +33550,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none c_type; + typedef ::neuroml2::Nml2Quantity_voltage c_type; /** * @brief Attribute traits type. @@ -29700,7 +33608,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none d_type; + typedef ::neuroml2::Nml2Quantity_current d_type; /** * @brief Attribute traits type. @@ -29756,13 +33664,17 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - IzhikevichCell (const id_type&, - const v0_type&, - const thresh_type&, - const a_type&, - const b_type&, - const c_type&, - const d_type&); + Izhikevich2007Cell (const id_type&, + const C_type&, + const v0_type&, + const k_type&, + const vr_type&, + const vt_type&, + const vpeak_type&, + const a_type&, + const b_type&, + const c_type&, + const d_type&); /** * @brief Create an instance from a DOM element. @@ -29772,9 +33684,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - IzhikevichCell (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + Izhikevich2007Cell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -29785,9 +33697,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IzhikevichCell (const IzhikevichCell& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + Izhikevich2007Cell (const Izhikevich2007Cell& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -29800,7 +33712,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual IzhikevichCell* + virtual Izhikevich2007Cell* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -29812,8 +33724,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - IzhikevichCell& - operator= (const IzhikevichCell& x); + Izhikevich2007Cell& + operator= (const Izhikevich2007Cell& x); //@} @@ -29821,7 +33733,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~IzhikevichCell (); + ~Izhikevich2007Cell (); // Implementation. // @@ -29835,7 +33747,10 @@ namespace neuroml2 protected: ::xsd::cxx::tree::one< v0_type > v0_; - ::xsd::cxx::tree::one< thresh_type > thresh_; + ::xsd::cxx::tree::one< k_type > k_; + ::xsd::cxx::tree::one< vr_type > vr_; + ::xsd::cxx::tree::one< vt_type > vt_; + ::xsd::cxx::tree::one< vpeak_type > vpeak_; ::xsd::cxx::tree::one< a_type > a_; ::xsd::cxx::tree::one< b_type > b_; ::xsd::cxx::tree::one< c_type > c_; @@ -29845,30 +33760,39 @@ namespace neuroml2 }; bool - operator== (const IzhikevichCell&, const IzhikevichCell&); + operator== (const Izhikevich2007Cell&, const Izhikevich2007Cell&); bool - operator!= (const IzhikevichCell&, const IzhikevichCell&); + operator!= (const Izhikevich2007Cell&, const Izhikevich2007Cell&); /** - * @brief Class corresponding to the %BaseCellMembPotCap schema type. + * @brief Class corresponding to the %AdExIaFCell schema type. * - * Any cell with a membrane potential **v** with voltage units and a - * membrane capacitance **C.** Also defines exposed value **iSyn** for - * current due to external synapses and **iMemb** for total - * transmembrane current ( usually channel currents plus **iSyn** ) + * Model based on Brette R and Gerstner W ( 2005 ) Adaptive Exponential + * Integrate-and-Fire Model as an Effective Description of Neuronal + * Activity. J Neurophysiol 94:3637-3642 + * @param gL Leak conductance + * @param EL Leak reversal potential + * @param VT Spike threshold + * @param thresh Spike detection threshold + * @param reset Reset potential + * @param delT Slope factor + * @param tauw Adaptation time constant + * @param refract Refractory period + * @param a Sub-threshold adaptation variable + * @param b Spike-triggered adaptation variable * @param C Total capacitance of the cell membrane * * @nosubgrouping */ - class BaseCellMembPotCap: public ::neuroml2::BaseCell + class AdExIaFCell: public ::neuroml2::BaseCellMembPotCap { public: /** - * @name C + * @name gL * - * @brief Accessor and modifier functions for the %C + * @brief Accessor and modifier functions for the %gL * required attribute. */ //@{ @@ -29876,28 +33800,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_capacitance C_type; + typedef ::neuroml2::Nml2Quantity_conductance gL_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< C_type, char > C_traits; + typedef ::xsd::cxx::tree::traits< gL_type, char > gL_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const C_type& - C () const; + const gL_type& + gL () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - C_type& - C (); + gL_type& + gL (); /** * @brief Set the attribute value. @@ -29908,7 +33832,7 @@ namespace neuroml2 * the new value of the attribute. */ void - C (const C_type& x); + gL (const gL_type& x); /** * @brief Set the attribute value without copying. @@ -29919,129 +33843,130 @@ namespace neuroml2 * instead of making a copy. */ void - C (::std::unique_ptr< C_type > p); + gL (::std::unique_ptr< gL_type > p); //@} /** - * @name Constructors + * @name EL + * + * @brief Accessor and modifier functions for the %EL + * required attribute. */ //@{ /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Attribute type. */ - BaseCellMembPotCap (const id_type&, - const C_type&); + typedef ::neuroml2::Nml2Quantity_voltage EL_type; /** - * @brief Create an instance from a DOM element. - * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @brief Attribute traits type. */ - BaseCellMembPotCap (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + typedef ::xsd::cxx::tree::traits< EL_type, char > EL_traits; /** - * @brief Copy constructor. + * @brief Return a read-only (constant) reference to the attribute. * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. + * @return A constant reference to the attribute. + */ + const EL_type& + EL () const; + + /** + * @brief Return a read-write reference to the attribute. * - * For polymorphic object models use the @c _clone function instead. + * @return A reference to the attribute. */ - BaseCellMembPotCap (const BaseCellMembPotCap& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + EL_type& + EL (); /** - * @brief Copy the instance polymorphically. + * @brief Set the attribute value. * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. + * @param x A new value to set. * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - virtual BaseCellMembPotCap* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; + void + EL (const EL_type& x); /** - * @brief Copy assignment operator. + * @brief Set the attribute value without copying. * - * @param x An instance to make a copy of. - * @return A reference to itself. + * @param p A new value to use. * - * For polymorphic object models use the @c _clone function instead. + * This function will try to use the passed value directly + * instead of making a copy. */ - BaseCellMembPotCap& - operator= (const BaseCellMembPotCap& x); + void + EL (::std::unique_ptr< EL_type > p); //@} /** - * @brief Destructor. + * @name reset + * + * @brief Accessor and modifier functions for the %reset + * required attribute. */ - virtual - ~BaseCellMembPotCap (); - - // Implementation. - // + //@{ - //@cond + /** + * @brief Attribute type. + */ + typedef ::neuroml2::Nml2Quantity_voltage reset_type; - protected: - void - parse (::xsd::cxx::xml::dom::parser< char >&, - ::xml_schema::flags); + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< reset_type, char > reset_traits; - protected: - ::xsd::cxx::tree::one< C_type > C_; + /** + * @brief Return a read-only (constant) reference to the attribute. + * + * @return A constant reference to the attribute. + */ + const reset_type& + reset () const; - //@endcond - }; + /** + * @brief Return a read-write reference to the attribute. + * + * @return A reference to the attribute. + */ + reset_type& + reset (); - bool - operator== (const BaseCellMembPotCap&, const BaseCellMembPotCap&); + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + reset (const reset_type& x); - bool - operator!= (const BaseCellMembPotCap&, const BaseCellMembPotCap&); + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + reset (::std::unique_ptr< reset_type > p); + //@} - /** - * @brief Class corresponding to the %Izhikevich2007Cell schema type. - * - * Cell based on the modified Izhikevich model in Izhikevich 2007, - * Dynamical systems in neuroscience, MIT Press - * @param v0 - * @param k - * @param vr - * @param vt - * @param vpeak - * @param a - * @param b - * @param c - * @param d - * @param C Total capacitance of the cell membrane - * - * @nosubgrouping - */ - class Izhikevich2007Cell: public ::neuroml2::BaseCellMembPotCap - { - public: /** - * @name v0 + * @name VT * - * @brief Accessor and modifier functions for the %v0 + * @brief Accessor and modifier functions for the %VT * required attribute. */ //@{ @@ -30049,28 +33974,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage v0_type; + typedef ::neuroml2::Nml2Quantity_voltage VT_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< v0_type, char > v0_traits; + typedef ::xsd::cxx::tree::traits< VT_type, char > VT_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const v0_type& - v0 () const; + const VT_type& + VT () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - v0_type& - v0 (); + VT_type& + VT (); /** * @brief Set the attribute value. @@ -30081,7 +34006,7 @@ namespace neuroml2 * the new value of the attribute. */ void - v0 (const v0_type& x); + VT (const VT_type& x); /** * @brief Set the attribute value without copying. @@ -30092,14 +34017,14 @@ namespace neuroml2 * instead of making a copy. */ void - v0 (::std::unique_ptr< v0_type > p); + VT (::std::unique_ptr< VT_type > p); //@} /** - * @name k + * @name thresh * - * @brief Accessor and modifier functions for the %k + * @brief Accessor and modifier functions for the %thresh * required attribute. */ //@{ @@ -30107,28 +34032,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductancePerVoltage k_type; + typedef ::neuroml2::Nml2Quantity_voltage thresh_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< k_type, char > k_traits; + typedef ::xsd::cxx::tree::traits< thresh_type, char > thresh_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const k_type& - k () const; + const thresh_type& + thresh () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - k_type& - k (); + thresh_type& + thresh (); /** * @brief Set the attribute value. @@ -30139,7 +34064,7 @@ namespace neuroml2 * the new value of the attribute. */ void - k (const k_type& x); + thresh (const thresh_type& x); /** * @brief Set the attribute value without copying. @@ -30150,14 +34075,14 @@ namespace neuroml2 * instead of making a copy. */ void - k (::std::unique_ptr< k_type > p); + thresh (::std::unique_ptr< thresh_type > p); //@} /** - * @name vr + * @name delT * - * @brief Accessor and modifier functions for the %vr + * @brief Accessor and modifier functions for the %delT * required attribute. */ //@{ @@ -30165,28 +34090,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage vr_type; + typedef ::neuroml2::Nml2Quantity_voltage delT_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< vr_type, char > vr_traits; + typedef ::xsd::cxx::tree::traits< delT_type, char > delT_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const vr_type& - vr () const; + const delT_type& + delT () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - vr_type& - vr (); + delT_type& + delT (); /** * @brief Set the attribute value. @@ -30197,7 +34122,7 @@ namespace neuroml2 * the new value of the attribute. */ void - vr (const vr_type& x); + delT (const delT_type& x); /** * @brief Set the attribute value without copying. @@ -30208,14 +34133,14 @@ namespace neuroml2 * instead of making a copy. */ void - vr (::std::unique_ptr< vr_type > p); + delT (::std::unique_ptr< delT_type > p); //@} /** - * @name vt + * @name tauw * - * @brief Accessor and modifier functions for the %vt + * @brief Accessor and modifier functions for the %tauw * required attribute. */ //@{ @@ -30223,28 +34148,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage vt_type; + typedef ::neuroml2::Nml2Quantity_time tauw_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< vt_type, char > vt_traits; + typedef ::xsd::cxx::tree::traits< tauw_type, char > tauw_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const vt_type& - vt () const; + const tauw_type& + tauw () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - vt_type& - vt (); + tauw_type& + tauw (); /** * @brief Set the attribute value. @@ -30255,7 +34180,7 @@ namespace neuroml2 * the new value of the attribute. */ void - vt (const vt_type& x); + tauw (const tauw_type& x); /** * @brief Set the attribute value without copying. @@ -30266,14 +34191,14 @@ namespace neuroml2 * instead of making a copy. */ void - vt (::std::unique_ptr< vt_type > p); + tauw (::std::unique_ptr< tauw_type > p); //@} /** - * @name vpeak + * @name refract * - * @brief Accessor and modifier functions for the %vpeak + * @brief Accessor and modifier functions for the %refract * required attribute. */ //@{ @@ -30281,28 +34206,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage vpeak_type; + typedef ::neuroml2::Nml2Quantity_time refract_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< vpeak_type, char > vpeak_traits; + typedef ::xsd::cxx::tree::traits< refract_type, char > refract_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const vpeak_type& - vpeak () const; + const refract_type& + refract () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - vpeak_type& - vpeak (); + refract_type& + refract (); /** * @brief Set the attribute value. @@ -30313,7 +34238,7 @@ namespace neuroml2 * the new value of the attribute. */ void - vpeak (const vpeak_type& x); + refract (const refract_type& x); /** * @brief Set the attribute value without copying. @@ -30324,7 +34249,7 @@ namespace neuroml2 * instead of making a copy. */ void - vpeak (::std::unique_ptr< vpeak_type > p); + refract (::std::unique_ptr< refract_type > p); //@} @@ -30339,7 +34264,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_pertime a_type; + typedef ::neuroml2::Nml2Quantity_conductance a_type; /** * @brief Attribute traits type. @@ -30397,7 +34322,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductance b_type; + typedef ::neuroml2::Nml2Quantity_current b_type; /** * @brief Attribute traits type. @@ -30445,67 +34370,135 @@ namespace neuroml2 //@} /** - * @name c - * - * @brief Accessor and modifier functions for the %c - * required attribute. + * @name Constructors */ //@{ /** - * @brief Attribute type. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. */ - typedef ::neuroml2::Nml2Quantity_voltage c_type; + AdExIaFCell (const id_type&, + const C_type&, + const gL_type&, + const EL_type&, + const reset_type&, + const VT_type&, + const thresh_type&, + const delT_type&, + const tauw_type&, + const refract_type&, + const a_type&, + const b_type&); /** - * @brief Attribute traits type. + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - typedef ::xsd::cxx::tree::traits< c_type, char > c_traits; + AdExIaFCell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Copy constructor. * - * @return A constant reference to the attribute. + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. */ - const c_type& - c () const; + AdExIaFCell (const AdExIaFCell& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-write reference to the attribute. + * @brief Copy the instance polymorphically. * - * @return A reference to the attribute. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - c_type& - c (); + virtual AdExIaFCell* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; /** - * @brief Set the attribute value. + * @brief Copy assignment operator. * - * @param x A new value to set. + * @param x An instance to make a copy of. + * @return A reference to itself. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * For polymorphic object models use the @c _clone function instead. */ - void - c (const c_type& x); + AdExIaFCell& + operator= (const AdExIaFCell& x); + + //@} /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. + * @brief Destructor. */ + virtual + ~AdExIaFCell (); + + // Implementation. + // + + //@cond + + protected: void - c (::std::unique_ptr< c_type > p); + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); - //@} + protected: + ::xsd::cxx::tree::one< gL_type > gL_; + ::xsd::cxx::tree::one< EL_type > EL_; + ::xsd::cxx::tree::one< reset_type > reset_; + ::xsd::cxx::tree::one< VT_type > VT_; + ::xsd::cxx::tree::one< thresh_type > thresh_; + ::xsd::cxx::tree::one< delT_type > delT_; + ::xsd::cxx::tree::one< tauw_type > tauw_; + ::xsd::cxx::tree::one< refract_type > refract_; + ::xsd::cxx::tree::one< a_type > a_; + ::xsd::cxx::tree::one< b_type > b_; + + //@endcond + }; + + bool + operator== (const AdExIaFCell&, const AdExIaFCell&); + + bool + operator!= (const AdExIaFCell&, const AdExIaFCell&); + + /** + * @brief Class corresponding to the %FitzHughNagumoCell schema type. + * + * Simple dimensionless model of spiking cell from FitzHugh and Nagumo. + * Superseded by **fitzHughNagumo1969Cell** ( See + * https://github.com/NeuroML/NeuroML2/issues/42 ) + * @param I + * + * @nosubgrouping + */ + class FitzHughNagumoCell: public ::neuroml2::BaseCell + { + public: /** - * @name d + * @name I * - * @brief Accessor and modifier functions for the %d + * @brief Accessor and modifier functions for the %I * required attribute. */ //@{ @@ -30513,28 +34506,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_current d_type; + typedef ::neuroml2::Nml2Quantity_none I_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< d_type, char > d_traits; + typedef ::xsd::cxx::tree::traits< I_type, char > I_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const d_type& - d () const; + const I_type& + I () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - d_type& - d (); + I_type& + I (); /** * @brief Set the attribute value. @@ -30545,7 +34538,7 @@ namespace neuroml2 * the new value of the attribute. */ void - d (const d_type& x); + I (const I_type& x); /** * @brief Set the attribute value without copying. @@ -30556,30 +34549,21 @@ namespace neuroml2 * instead of making a copy. */ void - d (::std::unique_ptr< d_type > p); + I (::std::unique_ptr< I_type > p); //@} /** * @name Constructors */ - //@{ - - /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. - */ - Izhikevich2007Cell (const id_type&, - const C_type&, - const v0_type&, - const k_type&, - const vr_type&, - const vt_type&, - const vpeak_type&, - const a_type&, - const b_type&, - const c_type&, - const d_type&); + //@{ + + /** + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. + */ + FitzHughNagumoCell (const id_type&, + const I_type&); /** * @brief Create an instance from a DOM element. @@ -30589,7 +34573,7 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - Izhikevich2007Cell (const ::xercesc::DOMElement& e, + FitzHughNagumoCell (const ::xercesc::DOMElement& e, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -30602,7 +34586,7 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - Izhikevich2007Cell (const Izhikevich2007Cell& x, + FitzHughNagumoCell (const FitzHughNagumoCell& x, ::xml_schema::flags f = 0, ::xml_schema::container* c = 0); @@ -30617,7 +34601,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual Izhikevich2007Cell* + virtual FitzHughNagumoCell* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -30629,8 +34613,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - Izhikevich2007Cell& - operator= (const Izhikevich2007Cell& x); + FitzHughNagumoCell& + operator= (const FitzHughNagumoCell& x); //@} @@ -30638,7 +34622,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~Izhikevich2007Cell (); + ~FitzHughNagumoCell (); // Implementation. // @@ -30651,53 +34635,49 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< v0_type > v0_; - ::xsd::cxx::tree::one< k_type > k_; - ::xsd::cxx::tree::one< vr_type > vr_; - ::xsd::cxx::tree::one< vt_type > vt_; - ::xsd::cxx::tree::one< vpeak_type > vpeak_; - ::xsd::cxx::tree::one< a_type > a_; - ::xsd::cxx::tree::one< b_type > b_; - ::xsd::cxx::tree::one< c_type > c_; - ::xsd::cxx::tree::one< d_type > d_; + ::xsd::cxx::tree::one< I_type > I_; //@endcond }; bool - operator== (const Izhikevich2007Cell&, const Izhikevich2007Cell&); + operator== (const FitzHughNagumoCell&, const FitzHughNagumoCell&); bool - operator!= (const Izhikevich2007Cell&, const Izhikevich2007Cell&); + operator!= (const FitzHughNagumoCell&, const FitzHughNagumoCell&); /** - * @brief Class corresponding to the %AdExIaFCell schema type. + * @brief Class corresponding to the %FitzHughNagumo1969Cell schema type. * - * Model based on Brette R and Gerstner W ( 2005 ) Adaptive Exponential - * Integrate-and-Fire Model as an Effective Description of Neuronal - * Activity. J Neurophysiol 94:3637-3642 - * @param gL - * @param EL - * @param VT - * @param thresh - * @param reset - * @param delT - * @param tauw - * @param refract + * The Fitzhugh Nagumo model is a two-dimensional simplification of the + * Hodgkin-Huxley model of spike generation in squid giant axons. This + * system was suggested by FitzHugh ( FitzHugh R. [1961]: Impulses and + * physiological states in theoretical models of nerve membrane. + * Biophysical J. 1:445-466 ), who called it " Bonhoeffer-van der Pol + * model ", and the equivalent circuit by Nagumo et al. ( Nagumo J. , + * Arimoto S. , and Yoshizawa S. [1962] An active pulse transmission line + * simulating nerve axon. Proc IRE. 50:2061-2070. 1962 ). This version + * corresponds to the one described in FitzHugh R. [1969]: Mathematical + * models of excitation and propagation in nerve. Chapter 1 ( pp. 1-85 in + * H. P. Schwan, ed. Biological Engineering, McGraw-Hill Book Co. , N. Y. + * ) * @param a * @param b - * @param C Total capacitance of the cell membrane + * @param I plays the role of an external injected current + * @param phi + * @param V0 + * @param W0 * * @nosubgrouping */ - class AdExIaFCell: public ::neuroml2::BaseCellMembPotCap + class FitzHughNagumo1969Cell: public ::neuroml2::BaseCell { public: /** - * @name gL + * @name a * - * @brief Accessor and modifier functions for the %gL + * @brief Accessor and modifier functions for the %a * required attribute. */ //@{ @@ -30705,28 +34685,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductance gL_type; + typedef ::neuroml2::Nml2Quantity_none a_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gL_type, char > gL_traits; + typedef ::xsd::cxx::tree::traits< a_type, char > a_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gL_type& - gL () const; + const a_type& + a () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gL_type& - gL (); + a_type& + a (); /** * @brief Set the attribute value. @@ -30737,7 +34717,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gL (const gL_type& x); + a (const a_type& x); /** * @brief Set the attribute value without copying. @@ -30748,14 +34728,14 @@ namespace neuroml2 * instead of making a copy. */ void - gL (::std::unique_ptr< gL_type > p); + a (::std::unique_ptr< a_type > p); //@} /** - * @name EL + * @name b * - * @brief Accessor and modifier functions for the %EL + * @brief Accessor and modifier functions for the %b * required attribute. */ //@{ @@ -30763,28 +34743,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage EL_type; + typedef ::neuroml2::Nml2Quantity_none b_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< EL_type, char > EL_traits; + typedef ::xsd::cxx::tree::traits< b_type, char > b_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const EL_type& - EL () const; + const b_type& + b () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - EL_type& - EL (); + b_type& + b (); /** * @brief Set the attribute value. @@ -30795,7 +34775,7 @@ namespace neuroml2 * the new value of the attribute. */ void - EL (const EL_type& x); + b (const b_type& x); /** * @brief Set the attribute value without copying. @@ -30806,14 +34786,14 @@ namespace neuroml2 * instead of making a copy. */ void - EL (::std::unique_ptr< EL_type > p); + b (::std::unique_ptr< b_type > p); //@} /** - * @name reset + * @name I * - * @brief Accessor and modifier functions for the %reset + * @brief Accessor and modifier functions for the %I * required attribute. */ //@{ @@ -30821,28 +34801,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage reset_type; + typedef ::neuroml2::Nml2Quantity_none I_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< reset_type, char > reset_traits; + typedef ::xsd::cxx::tree::traits< I_type, char > I_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const reset_type& - reset () const; + const I_type& + I () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - reset_type& - reset (); + I_type& + I (); /** * @brief Set the attribute value. @@ -30853,7 +34833,7 @@ namespace neuroml2 * the new value of the attribute. */ void - reset (const reset_type& x); + I (const I_type& x); /** * @brief Set the attribute value without copying. @@ -30864,14 +34844,14 @@ namespace neuroml2 * instead of making a copy. */ void - reset (::std::unique_ptr< reset_type > p); + I (::std::unique_ptr< I_type > p); //@} /** - * @name VT + * @name phi * - * @brief Accessor and modifier functions for the %VT + * @brief Accessor and modifier functions for the %phi * required attribute. */ //@{ @@ -30879,28 +34859,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage VT_type; + typedef ::neuroml2::Nml2Quantity_none phi_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< VT_type, char > VT_traits; + typedef ::xsd::cxx::tree::traits< phi_type, char > phi_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const VT_type& - VT () const; + const phi_type& + phi () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - VT_type& - VT (); + phi_type& + phi (); /** * @brief Set the attribute value. @@ -30911,7 +34891,7 @@ namespace neuroml2 * the new value of the attribute. */ void - VT (const VT_type& x); + phi (const phi_type& x); /** * @brief Set the attribute value without copying. @@ -30922,14 +34902,14 @@ namespace neuroml2 * instead of making a copy. */ void - VT (::std::unique_ptr< VT_type > p); + phi (::std::unique_ptr< phi_type > p); //@} /** - * @name thresh + * @name V0 * - * @brief Accessor and modifier functions for the %thresh + * @brief Accessor and modifier functions for the %V0 * required attribute. */ //@{ @@ -30937,28 +34917,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage thresh_type; + typedef ::neuroml2::Nml2Quantity_none V0_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< thresh_type, char > thresh_traits; + typedef ::xsd::cxx::tree::traits< V0_type, char > V0_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const thresh_type& - thresh () const; + const V0_type& + V0 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - thresh_type& - thresh (); + V0_type& + V0 (); /** * @brief Set the attribute value. @@ -30969,7 +34949,7 @@ namespace neuroml2 * the new value of the attribute. */ void - thresh (const thresh_type& x); + V0 (const V0_type& x); /** * @brief Set the attribute value without copying. @@ -30980,14 +34960,14 @@ namespace neuroml2 * instead of making a copy. */ void - thresh (::std::unique_ptr< thresh_type > p); + V0 (::std::unique_ptr< V0_type > p); //@} /** - * @name delT + * @name W0 * - * @brief Accessor and modifier functions for the %delT + * @brief Accessor and modifier functions for the %W0 * required attribute. */ //@{ @@ -30995,28 +34975,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage delT_type; + typedef ::neuroml2::Nml2Quantity_none W0_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< delT_type, char > delT_traits; + typedef ::xsd::cxx::tree::traits< W0_type, char > W0_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const delT_type& - delT () const; + const W0_type& + W0 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - delT_type& - delT (); + W0_type& + W0 (); /** * @brief Set the attribute value. @@ -31027,7 +35007,7 @@ namespace neuroml2 * the new value of the attribute. */ void - delT (const delT_type& x); + W0 (const W0_type& x); /** * @brief Set the attribute value without copying. @@ -31038,72 +35018,152 @@ namespace neuroml2 * instead of making a copy. */ void - delT (::std::unique_ptr< delT_type > p); + W0 (::std::unique_ptr< W0_type > p); //@} /** - * @name tauw - * - * @brief Accessor and modifier functions for the %tauw - * required attribute. + * @name Constructors */ //@{ /** - * @brief Attribute type. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. */ - typedef ::neuroml2::Nml2Quantity_time tauw_type; + FitzHughNagumo1969Cell (const id_type&, + const a_type&, + const b_type&, + const I_type&, + const phi_type&, + const V0_type&, + const W0_type&); /** - * @brief Attribute traits type. + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - typedef ::xsd::cxx::tree::traits< tauw_type, char > tauw_traits; + FitzHughNagumo1969Cell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Copy constructor. * - * @return A constant reference to the attribute. + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. */ - const tauw_type& - tauw () const; + FitzHughNagumo1969Cell (const FitzHughNagumo1969Cell& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-write reference to the attribute. + * @brief Copy the instance polymorphically. * - * @return A reference to the attribute. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - tauw_type& - tauw (); + virtual FitzHughNagumo1969Cell* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; /** - * @brief Set the attribute value. + * @brief Copy assignment operator. * - * @param x A new value to set. + * @param x An instance to make a copy of. + * @return A reference to itself. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * For polymorphic object models use the @c _clone function instead. */ - void - tauw (const tauw_type& x); + FitzHughNagumo1969Cell& + operator= (const FitzHughNagumo1969Cell& x); + + //@} /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. + * @brief Destructor. */ + virtual + ~FitzHughNagumo1969Cell (); + + // Implementation. + // + + //@cond + + protected: void - tauw (::std::unique_ptr< tauw_type > p); + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); - //@} + protected: + ::xsd::cxx::tree::one< a_type > a_; + ::xsd::cxx::tree::one< b_type > b_; + ::xsd::cxx::tree::one< I_type > I_; + ::xsd::cxx::tree::one< phi_type > phi_; + ::xsd::cxx::tree::one< V0_type > V0_; + ::xsd::cxx::tree::one< W0_type > W0_; + + //@endcond + }; + bool + operator== (const FitzHughNagumo1969Cell&, const FitzHughNagumo1969Cell&); + + bool + operator!= (const FitzHughNagumo1969Cell&, const FitzHughNagumo1969Cell&); + + + /** + * @brief Class corresponding to the %PinskyRinzelCA3Cell schema type. + * + * Reduced CA3 cell model from Pinsky, P. F. , Rinzel, J. Intrinsic and + * network rhythmogenesis in a reduced traub model for CA3 neurons. J + * Comput Neurosci 1, 39-60 ( 1994 ). See + * https://github.com/OpenSourceBrain/PinskyRinzelModel + * @param iSoma + * @param iDend + * @param gLs + * @param gLd + * @param gNa + * @param gKdr + * @param gCa + * @param gKahp + * @param gKC + * @param gc + * @param eNa + * @param eCa + * @param eK + * @param eL + * @param pp + * @param cm + * @param alphac + * @param betac + * @param gNmda + * @param gAmpa + * @param qd0 + * + * @nosubgrouping + */ + class PinskyRinzelCA3Cell: public ::neuroml2::BaseCell + { + public: /** - * @name refract + * @name iSoma * - * @brief Accessor and modifier functions for the %refract + * @brief Accessor and modifier functions for the %iSoma * required attribute. */ //@{ @@ -31111,28 +35171,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_time refract_type; + typedef ::neuroml2::Nml2Quantity_currentDensity iSoma_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< refract_type, char > refract_traits; + typedef ::xsd::cxx::tree::traits< iSoma_type, char > iSoma_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const refract_type& - refract () const; + const iSoma_type& + iSoma () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - refract_type& - refract (); + iSoma_type& + iSoma (); /** * @brief Set the attribute value. @@ -31143,7 +35203,7 @@ namespace neuroml2 * the new value of the attribute. */ void - refract (const refract_type& x); + iSoma (const iSoma_type& x); /** * @brief Set the attribute value without copying. @@ -31154,14 +35214,14 @@ namespace neuroml2 * instead of making a copy. */ void - refract (::std::unique_ptr< refract_type > p); + iSoma (::std::unique_ptr< iSoma_type > p); //@} /** - * @name a + * @name iDend * - * @brief Accessor and modifier functions for the %a + * @brief Accessor and modifier functions for the %iDend * required attribute. */ //@{ @@ -31169,28 +35229,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductance a_type; + typedef ::neuroml2::Nml2Quantity_currentDensity iDend_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< a_type, char > a_traits; + typedef ::xsd::cxx::tree::traits< iDend_type, char > iDend_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const a_type& - a () const; + const iDend_type& + iDend () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - a_type& - a (); + iDend_type& + iDend (); /** * @brief Set the attribute value. @@ -31201,7 +35261,7 @@ namespace neuroml2 * the new value of the attribute. */ void - a (const a_type& x); + iDend (const iDend_type& x); /** * @brief Set the attribute value without copying. @@ -31212,14 +35272,14 @@ namespace neuroml2 * instead of making a copy. */ void - a (::std::unique_ptr< a_type > p); + iDend (::std::unique_ptr< iDend_type > p); //@} /** - * @name b + * @name gc * - * @brief Accessor and modifier functions for the %b + * @brief Accessor and modifier functions for the %gc * required attribute. */ //@{ @@ -31227,28 +35287,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_current b_type; + typedef ::neuroml2::Nml2Quantity_conductanceDensity gc_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< b_type, char > b_traits; + typedef ::xsd::cxx::tree::traits< gc_type, char > gc_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const b_type& - b () const; + const gc_type& + gc () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - b_type& - b (); + gc_type& + gc (); /** * @brief Set the attribute value. @@ -31259,151 +35319,25 @@ namespace neuroml2 * the new value of the attribute. */ void - b (const b_type& x); + gc (const gc_type& x); /** * @brief Set the attribute value without copying. * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. - */ - void - b (::std::unique_ptr< b_type > p); - - //@} - - /** - * @name Constructors - */ - //@{ - - /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. - */ - AdExIaFCell (const id_type&, - const C_type&, - const gL_type&, - const EL_type&, - const reset_type&, - const VT_type&, - const thresh_type&, - const delT_type&, - const tauw_type&, - const refract_type&, - const a_type&, - const b_type&); - - /** - * @brief Create an instance from a DOM element. - * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. - */ - AdExIaFCell (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Copy constructor. - * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * - * For polymorphic object models use the @c _clone function instead. - */ - AdExIaFCell (const AdExIaFCell& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); - - /** - * @brief Copy the instance polymorphically. - * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. - * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. - */ - virtual AdExIaFCell* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; - - /** - * @brief Copy assignment operator. - * - * @param x An instance to make a copy of. - * @return A reference to itself. - * - * For polymorphic object models use the @c _clone function instead. - */ - AdExIaFCell& - operator= (const AdExIaFCell& x); - - //@} - - /** - * @brief Destructor. - */ - virtual - ~AdExIaFCell (); - - // Implementation. - // - - //@cond - - protected: - void - parse (::xsd::cxx::xml::dom::parser< char >&, - ::xml_schema::flags); - - protected: - ::xsd::cxx::tree::one< gL_type > gL_; - ::xsd::cxx::tree::one< EL_type > EL_; - ::xsd::cxx::tree::one< reset_type > reset_; - ::xsd::cxx::tree::one< VT_type > VT_; - ::xsd::cxx::tree::one< thresh_type > thresh_; - ::xsd::cxx::tree::one< delT_type > delT_; - ::xsd::cxx::tree::one< tauw_type > tauw_; - ::xsd::cxx::tree::one< refract_type > refract_; - ::xsd::cxx::tree::one< a_type > a_; - ::xsd::cxx::tree::one< b_type > b_; - - //@endcond - }; - - bool - operator== (const AdExIaFCell&, const AdExIaFCell&); - - bool - operator!= (const AdExIaFCell&, const AdExIaFCell&); - - - /** - * @brief Class corresponding to the %FitzHughNagumoCell schema type. - * - * Simple dimensionless model of spiking cell from FitzHugh and Nagumo. - * Superseded by **fitzHughNagumo1969Cell** ( See - * https://github.com/NeuroML/NeuroML2/issues/42 ) - * @param I - * - * @nosubgrouping - */ - class FitzHughNagumoCell: public ::neuroml2::BaseCell - { - public: + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. + */ + void + gc (::std::unique_ptr< gc_type > p); + + //@} + /** - * @name I + * @name gLs * - * @brief Accessor and modifier functions for the %I + * @brief Accessor and modifier functions for the %gLs * required attribute. */ //@{ @@ -31411,28 +35345,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none I_type; + typedef ::neuroml2::Nml2Quantity_conductanceDensity gLs_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< I_type, char > I_traits; + typedef ::xsd::cxx::tree::traits< gLs_type, char > gLs_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const I_type& - I () const; + const gLs_type& + gLs () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - I_type& - I (); + gLs_type& + gLs (); /** * @brief Set the attribute value. @@ -31443,7 +35377,7 @@ namespace neuroml2 * the new value of the attribute. */ void - I (const I_type& x); + gLs (const gLs_type& x); /** * @brief Set the attribute value without copying. @@ -31454,135 +35388,72 @@ namespace neuroml2 * instead of making a copy. */ void - I (::std::unique_ptr< I_type > p); + gLs (::std::unique_ptr< gLs_type > p); //@} /** - * @name Constructors + * @name gLd + * + * @brief Accessor and modifier functions for the %gLd + * required attribute. */ //@{ /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Attribute type. */ - FitzHughNagumoCell (const id_type&, - const I_type&); + typedef ::neuroml2::Nml2Quantity_conductanceDensity gLd_type; /** - * @brief Create an instance from a DOM element. - * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @brief Attribute traits type. */ - FitzHughNagumoCell (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + typedef ::xsd::cxx::tree::traits< gLd_type, char > gLd_traits; /** - * @brief Copy constructor. - * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. + * @brief Return a read-only (constant) reference to the attribute. * - * For polymorphic object models use the @c _clone function instead. + * @return A constant reference to the attribute. */ - FitzHughNagumoCell (const FitzHughNagumoCell& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + const gLd_type& + gLd () const; /** - * @brief Copy the instance polymorphically. - * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. + * @brief Return a read-write reference to the attribute. * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. + * @return A reference to the attribute. */ - virtual FitzHughNagumoCell* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; + gLd_type& + gLd (); /** - * @brief Copy assignment operator. + * @brief Set the attribute value. * - * @param x An instance to make a copy of. - * @return A reference to itself. + * @param x A new value to set. * - * For polymorphic object models use the @c _clone function instead. + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - FitzHughNagumoCell& - operator= (const FitzHughNagumoCell& x); - - //@} + void + gLd (const gLd_type& x); /** - * @brief Destructor. + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. */ - virtual - ~FitzHughNagumoCell (); - - // Implementation. - // - - //@cond - - protected: void - parse (::xsd::cxx::xml::dom::parser< char >&, - ::xml_schema::flags); - - protected: - ::xsd::cxx::tree::one< I_type > I_; - - //@endcond - }; - - bool - operator== (const FitzHughNagumoCell&, const FitzHughNagumoCell&); - - bool - operator!= (const FitzHughNagumoCell&, const FitzHughNagumoCell&); + gLd (::std::unique_ptr< gLd_type > p); + //@} - /** - * @brief Class corresponding to the %FitzHughNagumo1969Cell schema type. - * - * The Fitzhugh Nagumo model is a two-dimensional simplification of the - * Hodgkin-Huxley model of spike generation in squid giant axons. This - * system was suggested by FitzHugh ( FitzHugh R. [1961]: Impulses and - * physiological states in theoretical models of nerve membrane. - * Biophysical J. 1:445-466 ), who called it " Bonhoeffer-van der Pol - * model ", and the equivalent circuit by Nagumo et al. ( Nagumo J. , - * Arimoto S. , and Yoshizawa S. [1962] An active pulse transmission line - * simulating nerve axon. Proc IRE. 50:2061-2070. 1962 ). This version - * corresponds to the one described in FitzHugh R. [1969]: Mathematical - * models of excitation and propagation in nerve. Chapter 1 ( pp. 1-85 in - * H. P. Schwan, ed. Biological Engineering, McGraw-Hill Book Co. , N. Y. - * ) - * @param a - * @param b - * @param I plays the role of an external injected current - * @param phi - * @param V0 - * @param W0 - * - * @nosubgrouping - */ - class FitzHughNagumo1969Cell: public ::neuroml2::BaseCell - { - public: /** - * @name a + * @name gNa * - * @brief Accessor and modifier functions for the %a + * @brief Accessor and modifier functions for the %gNa * required attribute. */ //@{ @@ -31590,28 +35461,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none a_type; + typedef ::neuroml2::Nml2Quantity_conductanceDensity gNa_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< a_type, char > a_traits; + typedef ::xsd::cxx::tree::traits< gNa_type, char > gNa_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const a_type& - a () const; + const gNa_type& + gNa () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - a_type& - a (); + gNa_type& + gNa (); /** * @brief Set the attribute value. @@ -31622,7 +35493,7 @@ namespace neuroml2 * the new value of the attribute. */ void - a (const a_type& x); + gNa (const gNa_type& x); /** * @brief Set the attribute value without copying. @@ -31633,14 +35504,14 @@ namespace neuroml2 * instead of making a copy. */ void - a (::std::unique_ptr< a_type > p); + gNa (::std::unique_ptr< gNa_type > p); //@} /** - * @name b + * @name gKdr * - * @brief Accessor and modifier functions for the %b + * @brief Accessor and modifier functions for the %gKdr * required attribute. */ //@{ @@ -31648,28 +35519,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none b_type; + typedef ::neuroml2::Nml2Quantity_conductanceDensity gKdr_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< b_type, char > b_traits; + typedef ::xsd::cxx::tree::traits< gKdr_type, char > gKdr_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const b_type& - b () const; + const gKdr_type& + gKdr () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - b_type& - b (); + gKdr_type& + gKdr (); /** * @brief Set the attribute value. @@ -31680,7 +35551,7 @@ namespace neuroml2 * the new value of the attribute. */ void - b (const b_type& x); + gKdr (const gKdr_type& x); /** * @brief Set the attribute value without copying. @@ -31691,14 +35562,14 @@ namespace neuroml2 * instead of making a copy. */ void - b (::std::unique_ptr< b_type > p); + gKdr (::std::unique_ptr< gKdr_type > p); //@} /** - * @name I + * @name gCa * - * @brief Accessor and modifier functions for the %I + * @brief Accessor and modifier functions for the %gCa * required attribute. */ //@{ @@ -31706,28 +35577,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none I_type; + typedef ::neuroml2::Nml2Quantity_conductanceDensity gCa_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< I_type, char > I_traits; + typedef ::xsd::cxx::tree::traits< gCa_type, char > gCa_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const I_type& - I () const; + const gCa_type& + gCa () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - I_type& - I (); + gCa_type& + gCa (); /** * @brief Set the attribute value. @@ -31738,7 +35609,7 @@ namespace neuroml2 * the new value of the attribute. */ void - I (const I_type& x); + gCa (const gCa_type& x); /** * @brief Set the attribute value without copying. @@ -31749,14 +35620,14 @@ namespace neuroml2 * instead of making a copy. */ void - I (::std::unique_ptr< I_type > p); + gCa (::std::unique_ptr< gCa_type > p); //@} /** - * @name phi + * @name gKahp * - * @brief Accessor and modifier functions for the %phi + * @brief Accessor and modifier functions for the %gKahp * required attribute. */ //@{ @@ -31764,28 +35635,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none phi_type; + typedef ::neuroml2::Nml2Quantity_conductanceDensity gKahp_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< phi_type, char > phi_traits; + typedef ::xsd::cxx::tree::traits< gKahp_type, char > gKahp_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const phi_type& - phi () const; + const gKahp_type& + gKahp () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - phi_type& - phi (); + gKahp_type& + gKahp (); /** * @brief Set the attribute value. @@ -31796,7 +35667,7 @@ namespace neuroml2 * the new value of the attribute. */ void - phi (const phi_type& x); + gKahp (const gKahp_type& x); /** * @brief Set the attribute value without copying. @@ -31807,14 +35678,14 @@ namespace neuroml2 * instead of making a copy. */ void - phi (::std::unique_ptr< phi_type > p); + gKahp (::std::unique_ptr< gKahp_type > p); //@} /** - * @name V0 + * @name gKC * - * @brief Accessor and modifier functions for the %V0 + * @brief Accessor and modifier functions for the %gKC * required attribute. */ //@{ @@ -31822,28 +35693,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none V0_type; + typedef ::neuroml2::Nml2Quantity_conductanceDensity gKC_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< V0_type, char > V0_traits; + typedef ::xsd::cxx::tree::traits< gKC_type, char > gKC_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const V0_type& - V0 () const; + const gKC_type& + gKC () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - V0_type& - V0 (); + gKC_type& + gKC (); /** * @brief Set the attribute value. @@ -31854,7 +35725,7 @@ namespace neuroml2 * the new value of the attribute. */ void - V0 (const V0_type& x); + gKC (const gKC_type& x); /** * @brief Set the attribute value without copying. @@ -31865,14 +35736,14 @@ namespace neuroml2 * instead of making a copy. */ void - V0 (::std::unique_ptr< V0_type > p); + gKC (::std::unique_ptr< gKC_type > p); //@} /** - * @name W0 + * @name gNmda * - * @brief Accessor and modifier functions for the %W0 + * @brief Accessor and modifier functions for the %gNmda * required attribute. */ //@{ @@ -31880,28 +35751,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none W0_type; + typedef ::neuroml2::Nml2Quantity_conductanceDensity gNmda_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< W0_type, char > W0_traits; + typedef ::xsd::cxx::tree::traits< gNmda_type, char > gNmda_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const W0_type& - W0 () const; + const gNmda_type& + gNmda () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - W0_type& - W0 (); + gNmda_type& + gNmda (); /** * @brief Set the attribute value. @@ -31912,7 +35783,7 @@ namespace neuroml2 * the new value of the attribute. */ void - W0 (const W0_type& x); + gNmda (const gNmda_type& x); /** * @brief Set the attribute value without copying. @@ -31923,150 +35794,72 @@ namespace neuroml2 * instead of making a copy. */ void - W0 (::std::unique_ptr< W0_type > p); + gNmda (::std::unique_ptr< gNmda_type > p); //@} /** - * @name Constructors + * @name gAmpa + * + * @brief Accessor and modifier functions for the %gAmpa + * required attribute. */ //@{ /** - * @brief Create an instance from the ultimate base and - * initializers for required elements and attributes. + * @brief Attribute type. */ - FitzHughNagumo1969Cell (const id_type&, - const a_type&, - const b_type&, - const I_type&, - const phi_type&, - const V0_type&, - const W0_type&); + typedef ::neuroml2::Nml2Quantity_conductanceDensity gAmpa_type; /** - * @brief Create an instance from a DOM element. - * - * @param e A DOM element to extract the data from. - * @param f Flags to create the new instance with. - * @param c A pointer to the object that will contain the new - * instance. + * @brief Attribute traits type. */ - FitzHughNagumo1969Cell (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + typedef ::xsd::cxx::tree::traits< gAmpa_type, char > gAmpa_traits; /** - * @brief Copy constructor. - * - * @param x An instance to make a copy of. - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. + * @brief Return a read-only (constant) reference to the attribute. * - * For polymorphic object models use the @c _clone function instead. + * @return A constant reference to the attribute. */ - FitzHughNagumo1969Cell (const FitzHughNagumo1969Cell& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + const gAmpa_type& + gAmpa () const; /** - * @brief Copy the instance polymorphically. - * - * @param f Flags to create the copy with. - * @param c A pointer to the object that will contain the copy. - * @return A pointer to the dynamically allocated copy. + * @brief Return a read-write reference to the attribute. * - * This function ensures that the dynamic type of the instance is - * used for copying and should be used for polymorphic object - * models instead of the copy constructor. + * @return A reference to the attribute. */ - virtual FitzHughNagumo1969Cell* - _clone (::xml_schema::flags f = 0, - ::xml_schema::container* c = 0) const; + gAmpa_type& + gAmpa (); /** - * @brief Copy assignment operator. + * @brief Set the attribute value. * - * @param x An instance to make a copy of. - * @return A reference to itself. + * @param x A new value to set. * - * For polymorphic object models use the @c _clone function instead. + * This function makes a copy of its argument and sets it as + * the new value of the attribute. */ - FitzHughNagumo1969Cell& - operator= (const FitzHughNagumo1969Cell& x); - - //@} + void + gAmpa (const gAmpa_type& x); /** - * @brief Destructor. + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly + * instead of making a copy. */ - virtual - ~FitzHughNagumo1969Cell (); - - // Implementation. - // - - //@cond - - protected: void - parse (::xsd::cxx::xml::dom::parser< char >&, - ::xml_schema::flags); - - protected: - ::xsd::cxx::tree::one< a_type > a_; - ::xsd::cxx::tree::one< b_type > b_; - ::xsd::cxx::tree::one< I_type > I_; - ::xsd::cxx::tree::one< phi_type > phi_; - ::xsd::cxx::tree::one< V0_type > V0_; - ::xsd::cxx::tree::one< W0_type > W0_; - - //@endcond - }; - - bool - operator== (const FitzHughNagumo1969Cell&, const FitzHughNagumo1969Cell&); - - bool - operator!= (const FitzHughNagumo1969Cell&, const FitzHughNagumo1969Cell&); + gAmpa (::std::unique_ptr< gAmpa_type > p); + //@} - /** - * @brief Class corresponding to the %PinskyRinzelCA3Cell schema type. - * - * Reduced CA3 cell model from Pinsky and Rinzel 1994. See - * https://github.com/OpenSourceBrain/PinskyRinzelModel - * @param iSoma - * @param iDend - * @param gLs - * @param gLd - * @param gNa - * @param gKdr - * @param gCa - * @param gKahp - * @param gKC - * @param gc - * @param eNa - * @param eCa - * @param eK - * @param eL - * @param pp - * @param cm - * @param alphac - * @param betac - * @param gNmda - * @param gAmpa - * @param qd0 - * - * @nosubgrouping - */ - class PinskyRinzelCA3Cell: public ::neuroml2::BaseCell - { - public: /** - * @name iSoma + * @name eNa * - * @brief Accessor and modifier functions for the %iSoma + * @brief Accessor and modifier functions for the %eNa * required attribute. */ //@{ @@ -32074,28 +35867,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_currentDensity iSoma_type; + typedef ::neuroml2::Nml2Quantity_voltage eNa_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< iSoma_type, char > iSoma_traits; + typedef ::xsd::cxx::tree::traits< eNa_type, char > eNa_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const iSoma_type& - iSoma () const; + const eNa_type& + eNa () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - iSoma_type& - iSoma (); + eNa_type& + eNa (); /** * @brief Set the attribute value. @@ -32106,7 +35899,7 @@ namespace neuroml2 * the new value of the attribute. */ void - iSoma (const iSoma_type& x); + eNa (const eNa_type& x); /** * @brief Set the attribute value without copying. @@ -32117,14 +35910,14 @@ namespace neuroml2 * instead of making a copy. */ void - iSoma (::std::unique_ptr< iSoma_type > p); + eNa (::std::unique_ptr< eNa_type > p); //@} /** - * @name iDend + * @name eCa * - * @brief Accessor and modifier functions for the %iDend + * @brief Accessor and modifier functions for the %eCa * required attribute. */ //@{ @@ -32132,28 +35925,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_currentDensity iDend_type; + typedef ::neuroml2::Nml2Quantity_voltage eCa_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< iDend_type, char > iDend_traits; + typedef ::xsd::cxx::tree::traits< eCa_type, char > eCa_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const iDend_type& - iDend () const; + const eCa_type& + eCa () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - iDend_type& - iDend (); + eCa_type& + eCa (); /** * @brief Set the attribute value. @@ -32164,7 +35957,7 @@ namespace neuroml2 * the new value of the attribute. */ void - iDend (const iDend_type& x); + eCa (const eCa_type& x); /** * @brief Set the attribute value without copying. @@ -32175,14 +35968,14 @@ namespace neuroml2 * instead of making a copy. */ void - iDend (::std::unique_ptr< iDend_type > p); + eCa (::std::unique_ptr< eCa_type > p); //@} /** - * @name gc + * @name eK * - * @brief Accessor and modifier functions for the %gc + * @brief Accessor and modifier functions for the %eK * required attribute. */ //@{ @@ -32190,28 +35983,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductanceDensity gc_type; + typedef ::neuroml2::Nml2Quantity_voltage eK_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gc_type, char > gc_traits; + typedef ::xsd::cxx::tree::traits< eK_type, char > eK_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gc_type& - gc () const; + const eK_type& + eK () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gc_type& - gc (); + eK_type& + eK (); /** * @brief Set the attribute value. @@ -32222,7 +36015,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gc (const gc_type& x); + eK (const eK_type& x); /** * @brief Set the attribute value without copying. @@ -32233,14 +36026,14 @@ namespace neuroml2 * instead of making a copy. */ void - gc (::std::unique_ptr< gc_type > p); + eK (::std::unique_ptr< eK_type > p); //@} /** - * @name gLs + * @name eL * - * @brief Accessor and modifier functions for the %gLs + * @brief Accessor and modifier functions for the %eL * required attribute. */ //@{ @@ -32248,28 +36041,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductanceDensity gLs_type; + typedef ::neuroml2::Nml2Quantity_voltage eL_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gLs_type, char > gLs_traits; + typedef ::xsd::cxx::tree::traits< eL_type, char > eL_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gLs_type& - gLs () const; + const eL_type& + eL () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gLs_type& - gLs (); + eL_type& + eL (); /** * @brief Set the attribute value. @@ -32280,7 +36073,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gLs (const gLs_type& x); + eL (const eL_type& x); /** * @brief Set the attribute value without copying. @@ -32291,14 +36084,14 @@ namespace neuroml2 * instead of making a copy. */ void - gLs (::std::unique_ptr< gLs_type > p); + eL (::std::unique_ptr< eL_type > p); //@} /** - * @name gLd + * @name qd0 * - * @brief Accessor and modifier functions for the %gLd + * @brief Accessor and modifier functions for the %qd0 * required attribute. */ //@{ @@ -32306,28 +36099,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductanceDensity gLd_type; + typedef ::neuroml2::Nml2Quantity_none qd0_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gLd_type, char > gLd_traits; + typedef ::xsd::cxx::tree::traits< qd0_type, char > qd0_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gLd_type& - gLd () const; + const qd0_type& + qd0 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gLd_type& - gLd (); + qd0_type& + qd0 (); /** * @brief Set the attribute value. @@ -32338,7 +36131,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gLd (const gLd_type& x); + qd0 (const qd0_type& x); /** * @brief Set the attribute value without copying. @@ -32349,14 +36142,14 @@ namespace neuroml2 * instead of making a copy. */ void - gLd (::std::unique_ptr< gLd_type > p); + qd0 (::std::unique_ptr< qd0_type > p); //@} /** - * @name gNa + * @name pp * - * @brief Accessor and modifier functions for the %gNa + * @brief Accessor and modifier functions for the %pp * required attribute. */ //@{ @@ -32364,28 +36157,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductanceDensity gNa_type; + typedef ::neuroml2::Nml2Quantity_none pp_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gNa_type, char > gNa_traits; + typedef ::xsd::cxx::tree::traits< pp_type, char > pp_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gNa_type& - gNa () const; + const pp_type& + pp () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gNa_type& - gNa (); + pp_type& + pp (); /** * @brief Set the attribute value. @@ -32396,7 +36189,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gNa (const gNa_type& x); + pp (const pp_type& x); /** * @brief Set the attribute value without copying. @@ -32407,14 +36200,14 @@ namespace neuroml2 * instead of making a copy. */ void - gNa (::std::unique_ptr< gNa_type > p); + pp (::std::unique_ptr< pp_type > p); //@} /** - * @name gKdr + * @name alphac * - * @brief Accessor and modifier functions for the %gKdr + * @brief Accessor and modifier functions for the %alphac * required attribute. */ //@{ @@ -32422,28 +36215,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductanceDensity gKdr_type; + typedef ::neuroml2::Nml2Quantity_none alphac_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gKdr_type, char > gKdr_traits; + typedef ::xsd::cxx::tree::traits< alphac_type, char > alphac_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gKdr_type& - gKdr () const; + const alphac_type& + alphac () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gKdr_type& - gKdr (); + alphac_type& + alphac (); /** * @brief Set the attribute value. @@ -32454,7 +36247,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gKdr (const gKdr_type& x); + alphac (const alphac_type& x); /** * @brief Set the attribute value without copying. @@ -32465,14 +36258,14 @@ namespace neuroml2 * instead of making a copy. */ void - gKdr (::std::unique_ptr< gKdr_type > p); + alphac (::std::unique_ptr< alphac_type > p); //@} /** - * @name gCa + * @name betac * - * @brief Accessor and modifier functions for the %gCa + * @brief Accessor and modifier functions for the %betac * required attribute. */ //@{ @@ -32480,28 +36273,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductanceDensity gCa_type; + typedef ::neuroml2::Nml2Quantity_none betac_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gCa_type, char > gCa_traits; + typedef ::xsd::cxx::tree::traits< betac_type, char > betac_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gCa_type& - gCa () const; + const betac_type& + betac () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gCa_type& - gCa (); + betac_type& + betac (); /** * @brief Set the attribute value. @@ -32512,7 +36305,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gCa (const gCa_type& x); + betac (const betac_type& x); /** * @brief Set the attribute value without copying. @@ -32523,14 +36316,14 @@ namespace neuroml2 * instead of making a copy. */ void - gCa (::std::unique_ptr< gCa_type > p); + betac (::std::unique_ptr< betac_type > p); //@} /** - * @name gKahp + * @name cm * - * @brief Accessor and modifier functions for the %gKahp + * @brief Accessor and modifier functions for the %cm * required attribute. */ //@{ @@ -32538,28 +36331,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductanceDensity gKahp_type; + typedef ::neuroml2::Nml2Quantity_specificCapacitance cm_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gKahp_type, char > gKahp_traits; + typedef ::xsd::cxx::tree::traits< cm_type, char > cm_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gKahp_type& - gKahp () const; + const cm_type& + cm () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gKahp_type& - gKahp (); + cm_type& + cm (); /** * @brief Set the attribute value. @@ -32570,7 +36363,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gKahp (const gKahp_type& x); + cm (const cm_type& x); /** * @brief Set the attribute value without copying. @@ -32581,72 +36374,180 @@ namespace neuroml2 * instead of making a copy. */ void - gKahp (::std::unique_ptr< gKahp_type > p); + cm (::std::unique_ptr< cm_type > p); //@} /** - * @name gKC - * - * @brief Accessor and modifier functions for the %gKC - * required attribute. + * @name Constructors */ //@{ /** - * @brief Attribute type. + * @brief Create an instance from the ultimate base and + * initializers for required elements and attributes. */ - typedef ::neuroml2::Nml2Quantity_conductanceDensity gKC_type; + PinskyRinzelCA3Cell (const id_type&, + const iSoma_type&, + const iDend_type&, + const gc_type&, + const gLs_type&, + const gLd_type&, + const gNa_type&, + const gKdr_type&, + const gCa_type&, + const gKahp_type&, + const gKC_type&, + const gNmda_type&, + const gAmpa_type&, + const eNa_type&, + const eCa_type&, + const eK_type&, + const eL_type&, + const qd0_type&, + const pp_type&, + const alphac_type&, + const betac_type&, + const cm_type&); /** - * @brief Attribute traits type. + * @brief Create an instance from a DOM element. + * + * @param e A DOM element to extract the data from. + * @param f Flags to create the new instance with. + * @param c A pointer to the object that will contain the new + * instance. */ - typedef ::xsd::cxx::tree::traits< gKC_type, char > gKC_traits; + PinskyRinzelCA3Cell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-only (constant) reference to the attribute. + * @brief Copy constructor. * - * @return A constant reference to the attribute. + * @param x An instance to make a copy of. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * + * For polymorphic object models use the @c _clone function instead. */ - const gKC_type& - gKC () const; + PinskyRinzelCA3Cell (const PinskyRinzelCA3Cell& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** - * @brief Return a read-write reference to the attribute. + * @brief Copy the instance polymorphically. * - * @return A reference to the attribute. + * @param f Flags to create the copy with. + * @param c A pointer to the object that will contain the copy. + * @return A pointer to the dynamically allocated copy. + * + * This function ensures that the dynamic type of the instance is + * used for copying and should be used for polymorphic object + * models instead of the copy constructor. */ - gKC_type& - gKC (); + virtual PinskyRinzelCA3Cell* + _clone (::xml_schema::flags f = 0, + ::xml_schema::container* c = 0) const; /** - * @brief Set the attribute value. + * @brief Copy assignment operator. * - * @param x A new value to set. + * @param x An instance to make a copy of. + * @return A reference to itself. * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. + * For polymorphic object models use the @c _clone function instead. */ - void - gKC (const gKC_type& x); + PinskyRinzelCA3Cell& + operator= (const PinskyRinzelCA3Cell& x); + + //@} /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. + * @brief Destructor. */ + virtual + ~PinskyRinzelCA3Cell (); + + // Implementation. + // + + //@cond + + protected: void - gKC (::std::unique_ptr< gKC_type > p); + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + ::xsd::cxx::tree::one< iSoma_type > iSoma_; + ::xsd::cxx::tree::one< iDend_type > iDend_; + ::xsd::cxx::tree::one< gc_type > gc_; + ::xsd::cxx::tree::one< gLs_type > gLs_; + ::xsd::cxx::tree::one< gLd_type > gLd_; + ::xsd::cxx::tree::one< gNa_type > gNa_; + ::xsd::cxx::tree::one< gKdr_type > gKdr_; + ::xsd::cxx::tree::one< gCa_type > gCa_; + ::xsd::cxx::tree::one< gKahp_type > gKahp_; + ::xsd::cxx::tree::one< gKC_type > gKC_; + ::xsd::cxx::tree::one< gNmda_type > gNmda_; + ::xsd::cxx::tree::one< gAmpa_type > gAmpa_; + ::xsd::cxx::tree::one< eNa_type > eNa_; + ::xsd::cxx::tree::one< eCa_type > eCa_; + ::xsd::cxx::tree::one< eK_type > eK_; + ::xsd::cxx::tree::one< eL_type > eL_; + ::xsd::cxx::tree::one< qd0_type > qd0_; + ::xsd::cxx::tree::one< pp_type > pp_; + ::xsd::cxx::tree::one< alphac_type > alphac_; + ::xsd::cxx::tree::one< betac_type > betac_; + ::xsd::cxx::tree::one< cm_type > cm_; + + //@endcond + }; + + bool + operator== (const PinskyRinzelCA3Cell&, const PinskyRinzelCA3Cell&); + + bool + operator!= (const PinskyRinzelCA3Cell&, const PinskyRinzelCA3Cell&); - //@} + /** + * @brief Class corresponding to the %HindmarshRose1984Cell schema type. + * + * The Hindmarsh Rose model is a simplified point cell model which + * captures complex firing patterns of single neurons, such as periodic + * and chaotic bursting. It has a fast spiking subsystem, which is a + * generalization of the FitzHugh-Nagumo system, coupled to a slower + * subsystem which allows the model to fire bursts. The dynamical + * variables x, y, z correspond to the membrane potential, a recovery + * variable, and a slower adaptation current, respectively. See Hindmarsh + * J. L. , and Rose R. M. ( 1984 ) A model of neuronal bursting using + * three coupled first order differential equations. Proc. R. Soc. + * London, Ser. B 221:87?102. + * @param a cubic term in x nullcline + * @param b quadratic term in x nullcline + * @param c constant term in y nullcline + * @param d quadratic term in y nullcline + * @param r timescale separation between slow and fast subsystem ( r + * greater than 0; r much less than 1 ) + * @param s related to adaptation + * @param x1 related to the system's resting potential + * @param v_scaling scaling of x for physiological membrane potential + * @param x0 + * @param y0 + * @param z0 + * @param C Total capacitance of the cell membrane + * + * @nosubgrouping + */ + class HindmarshRose1984Cell: public ::neuroml2::BaseCellMembPotCap + { + public: /** - * @name gNmda + * @name a * - * @brief Accessor and modifier functions for the %gNmda + * @brief Accessor and modifier functions for the %a * required attribute. */ //@{ @@ -32654,28 +36555,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductanceDensity gNmda_type; + typedef ::neuroml2::Nml2Quantity_none a_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gNmda_type, char > gNmda_traits; + typedef ::xsd::cxx::tree::traits< a_type, char > a_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gNmda_type& - gNmda () const; + const a_type& + a () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gNmda_type& - gNmda (); + a_type& + a (); /** * @brief Set the attribute value. @@ -32686,7 +36587,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gNmda (const gNmda_type& x); + a (const a_type& x); /** * @brief Set the attribute value without copying. @@ -32697,14 +36598,14 @@ namespace neuroml2 * instead of making a copy. */ void - gNmda (::std::unique_ptr< gNmda_type > p); + a (::std::unique_ptr< a_type > p); //@} /** - * @name gAmpa + * @name b * - * @brief Accessor and modifier functions for the %gAmpa + * @brief Accessor and modifier functions for the %b * required attribute. */ //@{ @@ -32712,28 +36613,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_conductanceDensity gAmpa_type; + typedef ::neuroml2::Nml2Quantity_none b_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< gAmpa_type, char > gAmpa_traits; + typedef ::xsd::cxx::tree::traits< b_type, char > b_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const gAmpa_type& - gAmpa () const; + const b_type& + b () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - gAmpa_type& - gAmpa (); + b_type& + b (); /** * @brief Set the attribute value. @@ -32744,7 +36645,7 @@ namespace neuroml2 * the new value of the attribute. */ void - gAmpa (const gAmpa_type& x); + b (const b_type& x); /** * @brief Set the attribute value without copying. @@ -32755,14 +36656,14 @@ namespace neuroml2 * instead of making a copy. */ void - gAmpa (::std::unique_ptr< gAmpa_type > p); + b (::std::unique_ptr< b_type > p); //@} /** - * @name eNa + * @name c * - * @brief Accessor and modifier functions for the %eNa + * @brief Accessor and modifier functions for the %c * required attribute. */ //@{ @@ -32770,28 +36671,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage eNa_type; + typedef ::neuroml2::Nml2Quantity_none c_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< eNa_type, char > eNa_traits; + typedef ::xsd::cxx::tree::traits< c_type, char > c_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const eNa_type& - eNa () const; + const c_type& + c () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - eNa_type& - eNa (); + c_type& + c (); /** * @brief Set the attribute value. @@ -32802,7 +36703,7 @@ namespace neuroml2 * the new value of the attribute. */ void - eNa (const eNa_type& x); + c (const c_type& x); /** * @brief Set the attribute value without copying. @@ -32813,14 +36714,14 @@ namespace neuroml2 * instead of making a copy. */ void - eNa (::std::unique_ptr< eNa_type > p); + c (::std::unique_ptr< c_type > p); //@} /** - * @name eCa + * @name d * - * @brief Accessor and modifier functions for the %eCa + * @brief Accessor and modifier functions for the %d * required attribute. */ //@{ @@ -32828,28 +36729,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage eCa_type; + typedef ::neuroml2::Nml2Quantity_none d_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< eCa_type, char > eCa_traits; + typedef ::xsd::cxx::tree::traits< d_type, char > d_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const eCa_type& - eCa () const; + const d_type& + d () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - eCa_type& - eCa (); + d_type& + d (); /** * @brief Set the attribute value. @@ -32860,7 +36761,7 @@ namespace neuroml2 * the new value of the attribute. */ void - eCa (const eCa_type& x); + d (const d_type& x); /** * @brief Set the attribute value without copying. @@ -32871,14 +36772,14 @@ namespace neuroml2 * instead of making a copy. */ void - eCa (::std::unique_ptr< eCa_type > p); + d (::std::unique_ptr< d_type > p); //@} /** - * @name eK + * @name s * - * @brief Accessor and modifier functions for the %eK + * @brief Accessor and modifier functions for the %s * required attribute. */ //@{ @@ -32886,28 +36787,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage eK_type; + typedef ::neuroml2::Nml2Quantity_none s_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< eK_type, char > eK_traits; + typedef ::xsd::cxx::tree::traits< s_type, char > s_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const eK_type& - eK () const; + const s_type& + s () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - eK_type& - eK (); + s_type& + s (); /** * @brief Set the attribute value. @@ -32918,7 +36819,7 @@ namespace neuroml2 * the new value of the attribute. */ void - eK (const eK_type& x); + s (const s_type& x); /** * @brief Set the attribute value without copying. @@ -32929,14 +36830,14 @@ namespace neuroml2 * instead of making a copy. */ void - eK (::std::unique_ptr< eK_type > p); + s (::std::unique_ptr< s_type > p); //@} /** - * @name eL + * @name x1 * - * @brief Accessor and modifier functions for the %eL + * @brief Accessor and modifier functions for the %x1 * required attribute. */ //@{ @@ -32944,28 +36845,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_voltage eL_type; + typedef ::neuroml2::Nml2Quantity_none x1_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< eL_type, char > eL_traits; + typedef ::xsd::cxx::tree::traits< x1_type, char > x1_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const eL_type& - eL () const; + const x1_type& + x1 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - eL_type& - eL (); + x1_type& + x1 (); /** * @brief Set the attribute value. @@ -32976,7 +36877,7 @@ namespace neuroml2 * the new value of the attribute. */ void - eL (const eL_type& x); + x1 (const x1_type& x); /** * @brief Set the attribute value without copying. @@ -32987,14 +36888,14 @@ namespace neuroml2 * instead of making a copy. */ void - eL (::std::unique_ptr< eL_type > p); + x1 (::std::unique_ptr< x1_type > p); //@} /** - * @name qd0 + * @name r * - * @brief Accessor and modifier functions for the %qd0 + * @brief Accessor and modifier functions for the %r * required attribute. */ //@{ @@ -33002,28 +36903,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none qd0_type; + typedef ::neuroml2::Nml2Quantity_none r_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< qd0_type, char > qd0_traits; + typedef ::xsd::cxx::tree::traits< r_type, char > r_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const qd0_type& - qd0 () const; + const r_type& + r () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - qd0_type& - qd0 (); + r_type& + r (); /** * @brief Set the attribute value. @@ -33034,7 +36935,7 @@ namespace neuroml2 * the new value of the attribute. */ void - qd0 (const qd0_type& x); + r (const r_type& x); /** * @brief Set the attribute value without copying. @@ -33045,14 +36946,14 @@ namespace neuroml2 * instead of making a copy. */ void - qd0 (::std::unique_ptr< qd0_type > p); + r (::std::unique_ptr< r_type > p); //@} /** - * @name pp + * @name x0 * - * @brief Accessor and modifier functions for the %pp + * @brief Accessor and modifier functions for the %x0 * required attribute. */ //@{ @@ -33060,28 +36961,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none pp_type; + typedef ::neuroml2::Nml2Quantity_none x0_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< pp_type, char > pp_traits; + typedef ::xsd::cxx::tree::traits< x0_type, char > x0_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const pp_type& - pp () const; + const x0_type& + x0 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - pp_type& - pp (); + x0_type& + x0 (); /** * @brief Set the attribute value. @@ -33092,7 +36993,7 @@ namespace neuroml2 * the new value of the attribute. */ void - pp (const pp_type& x); + x0 (const x0_type& x); /** * @brief Set the attribute value without copying. @@ -33103,14 +37004,14 @@ namespace neuroml2 * instead of making a copy. */ void - pp (::std::unique_ptr< pp_type > p); + x0 (::std::unique_ptr< x0_type > p); //@} /** - * @name alphac + * @name y0 * - * @brief Accessor and modifier functions for the %alphac + * @brief Accessor and modifier functions for the %y0 * required attribute. */ //@{ @@ -33118,28 +37019,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none alphac_type; + typedef ::neuroml2::Nml2Quantity_none y0_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< alphac_type, char > alphac_traits; + typedef ::xsd::cxx::tree::traits< y0_type, char > y0_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const alphac_type& - alphac () const; + const y0_type& + y0 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - alphac_type& - alphac (); + y0_type& + y0 (); /** * @brief Set the attribute value. @@ -33150,7 +37051,7 @@ namespace neuroml2 * the new value of the attribute. */ void - alphac (const alphac_type& x); + y0 (const y0_type& x); /** * @brief Set the attribute value without copying. @@ -33161,14 +37062,14 @@ namespace neuroml2 * instead of making a copy. */ void - alphac (::std::unique_ptr< alphac_type > p); + y0 (::std::unique_ptr< y0_type > p); //@} /** - * @name betac + * @name z0 * - * @brief Accessor and modifier functions for the %betac + * @brief Accessor and modifier functions for the %z0 * required attribute. */ //@{ @@ -33176,28 +37077,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_none betac_type; + typedef ::neuroml2::Nml2Quantity_none z0_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< betac_type, char > betac_traits; + typedef ::xsd::cxx::tree::traits< z0_type, char > z0_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const betac_type& - betac () const; + const z0_type& + z0 () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - betac_type& - betac (); + z0_type& + z0 (); /** * @brief Set the attribute value. @@ -33208,7 +37109,7 @@ namespace neuroml2 * the new value of the attribute. */ void - betac (const betac_type& x); + z0 (const z0_type& x); /** * @brief Set the attribute value without copying. @@ -33219,14 +37120,14 @@ namespace neuroml2 * instead of making a copy. */ void - betac (::std::unique_ptr< betac_type > p); + z0 (::std::unique_ptr< z0_type > p); //@} /** - * @name cm + * @name v_scaling * - * @brief Accessor and modifier functions for the %cm + * @brief Accessor and modifier functions for the %v_scaling * required attribute. */ //@{ @@ -33234,28 +37135,28 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::neuroml2::Nml2Quantity_specificCapacitance cm_type; + typedef ::neuroml2::Nml2Quantity_voltage v_scaling_type; /** * @brief Attribute traits type. */ - typedef ::xsd::cxx::tree::traits< cm_type, char > cm_traits; + typedef ::xsd::cxx::tree::traits< v_scaling_type, char > v_scaling_traits; /** * @brief Return a read-only (constant) reference to the attribute. * * @return A constant reference to the attribute. */ - const cm_type& - cm () const; + const v_scaling_type& + v_scaling () const; /** * @brief Return a read-write reference to the attribute. * * @return A reference to the attribute. */ - cm_type& - cm (); + v_scaling_type& + v_scaling (); /** * @brief Set the attribute value. @@ -33266,7 +37167,7 @@ namespace neuroml2 * the new value of the attribute. */ void - cm (const cm_type& x); + v_scaling (const v_scaling_type& x); /** * @brief Set the attribute value without copying. @@ -33277,7 +37178,7 @@ namespace neuroml2 * instead of making a copy. */ void - cm (::std::unique_ptr< cm_type > p); + v_scaling (::std::unique_ptr< v_scaling_type > p); //@} @@ -33290,28 +37191,19 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - PinskyRinzelCA3Cell (const id_type&, - const iSoma_type&, - const iDend_type&, - const gc_type&, - const gLs_type&, - const gLd_type&, - const gNa_type&, - const gKdr_type&, - const gCa_type&, - const gKahp_type&, - const gKC_type&, - const gNmda_type&, - const gAmpa_type&, - const eNa_type&, - const eCa_type&, - const eK_type&, - const eL_type&, - const qd0_type&, - const pp_type&, - const alphac_type&, - const betac_type&, - const cm_type&); + HindmarshRose1984Cell (const id_type&, + const C_type&, + const a_type&, + const b_type&, + const c_type&, + const d_type&, + const s_type&, + const x1_type&, + const r_type&, + const x0_type&, + const y0_type&, + const z0_type&, + const v_scaling_type&); /** * @brief Create an instance from a DOM element. @@ -33321,9 +37213,9 @@ namespace neuroml2 * @param c A pointer to the object that will contain the new * instance. */ - PinskyRinzelCA3Cell (const ::xercesc::DOMElement& e, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + HindmarshRose1984Cell (const ::xercesc::DOMElement& e, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy constructor. @@ -33334,9 +37226,9 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - PinskyRinzelCA3Cell (const PinskyRinzelCA3Cell& x, - ::xml_schema::flags f = 0, - ::xml_schema::container* c = 0); + HindmarshRose1984Cell (const HindmarshRose1984Cell& x, + ::xml_schema::flags f = 0, + ::xml_schema::container* c = 0); /** * @brief Copy the instance polymorphically. @@ -33349,7 +37241,7 @@ namespace neuroml2 * used for copying and should be used for polymorphic object * models instead of the copy constructor. */ - virtual PinskyRinzelCA3Cell* + virtual HindmarshRose1984Cell* _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; @@ -33361,8 +37253,8 @@ namespace neuroml2 * * For polymorphic object models use the @c _clone function instead. */ - PinskyRinzelCA3Cell& - operator= (const PinskyRinzelCA3Cell& x); + HindmarshRose1984Cell& + operator= (const HindmarshRose1984Cell& x); //@} @@ -33370,7 +37262,7 @@ namespace neuroml2 * @brief Destructor. */ virtual - ~PinskyRinzelCA3Cell (); + ~HindmarshRose1984Cell (); // Implementation. // @@ -33383,36 +37275,26 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< iSoma_type > iSoma_; - ::xsd::cxx::tree::one< iDend_type > iDend_; - ::xsd::cxx::tree::one< gc_type > gc_; - ::xsd::cxx::tree::one< gLs_type > gLs_; - ::xsd::cxx::tree::one< gLd_type > gLd_; - ::xsd::cxx::tree::one< gNa_type > gNa_; - ::xsd::cxx::tree::one< gKdr_type > gKdr_; - ::xsd::cxx::tree::one< gCa_type > gCa_; - ::xsd::cxx::tree::one< gKahp_type > gKahp_; - ::xsd::cxx::tree::one< gKC_type > gKC_; - ::xsd::cxx::tree::one< gNmda_type > gNmda_; - ::xsd::cxx::tree::one< gAmpa_type > gAmpa_; - ::xsd::cxx::tree::one< eNa_type > eNa_; - ::xsd::cxx::tree::one< eCa_type > eCa_; - ::xsd::cxx::tree::one< eK_type > eK_; - ::xsd::cxx::tree::one< eL_type > eL_; - ::xsd::cxx::tree::one< qd0_type > qd0_; - ::xsd::cxx::tree::one< pp_type > pp_; - ::xsd::cxx::tree::one< alphac_type > alphac_; - ::xsd::cxx::tree::one< betac_type > betac_; - ::xsd::cxx::tree::one< cm_type > cm_; + ::xsd::cxx::tree::one< a_type > a_; + ::xsd::cxx::tree::one< b_type > b_; + ::xsd::cxx::tree::one< c_type > c_; + ::xsd::cxx::tree::one< d_type > d_; + ::xsd::cxx::tree::one< s_type > s_; + ::xsd::cxx::tree::one< x1_type > x1_; + ::xsd::cxx::tree::one< r_type > r_; + ::xsd::cxx::tree::one< x0_type > x0_; + ::xsd::cxx::tree::one< y0_type > y0_; + ::xsd::cxx::tree::one< z0_type > z0_; + ::xsd::cxx::tree::one< v_scaling_type > v_scaling_; //@endcond }; bool - operator== (const PinskyRinzelCA3Cell&, const PinskyRinzelCA3Cell&); + operator== (const HindmarshRose1984Cell&, const HindmarshRose1984Cell&); bool - operator!= (const PinskyRinzelCA3Cell&, const PinskyRinzelCA3Cell&); + operator!= (const HindmarshRose1984Cell&, const HindmarshRose1984Cell&); /** @@ -34719,6 +38601,82 @@ namespace neuroml2 //@} + /** + * @name neuroLexId + * + * @brief Accessor and modifier functions for the %neuroLexId + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::NeuroLexId neuroLexId_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< neuroLexId_type > neuroLexId_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< neuroLexId_type, char > neuroLexId_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. + */ + const neuroLexId_optional& + neuroLexId () const; + + /** + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. + */ + neuroLexId_optional& + neuroLexId (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + neuroLexId (const neuroLexId_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + neuroLexId (const neuroLexId_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + neuroLexId (::std::unique_ptr< neuroLexId_type > p); + + //@} + /** * @name Constructors */ @@ -34816,6 +38774,7 @@ namespace neuroml2 proximal_optional proximal_; ::xsd::cxx::tree::one< distal_type > distal_; name_optional name_; + neuroLexId_optional neuroLexId_; //@endcond }; @@ -34832,6 +38791,7 @@ namespace neuroml2 * * @nosubgrouping */ + class SegmentParent: public ::neuroml2::BaseWithoutId { public: /** @@ -35073,6 +39033,7 @@ namespace neuroml2 * * @nosubgrouping */ + class Point3DWithDiam: public ::neuroml2::BaseWithoutId { public: /** @@ -35930,6 +39891,82 @@ namespace neuroml2 //@} + /** + * @name neuroLexId + * + * @brief Accessor and modifier functions for the %neuroLexId + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::NeuroLexId neuroLexId_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< neuroLexId_type > neuroLexId_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< neuroLexId_type, char > neuroLexId_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. + */ + const neuroLexId_optional& + neuroLexId () const; + + /** + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. + */ + neuroLexId_optional& + neuroLexId (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + neuroLexId (const neuroLexId_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + neuroLexId (const neuroLexId_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + neuroLexId (::std::unique_ptr< neuroLexId_type > p); + + //@} + /** * @name Constructors */ @@ -36019,6 +40056,7 @@ namespace neuroml2 path_sequence path_; subTree_sequence subTree_; inhomogeneousParameter_sequence inhomogeneousParameter_; + neuroLexId_optional neuroLexId_; //@endcond }; @@ -36556,8 +40594,12 @@ namespace neuroml2 /** * @brief Class corresponding to the %ProximalDetails schema type. * + * What to do at the proximal point when creating an inhomogeneous + * parameter + * * @nosubgrouping */ + class ProximalDetails: public ::neuroml2::BaseWithoutId { public: /** @@ -36703,8 +40745,11 @@ namespace neuroml2 /** * @brief Class corresponding to the %DistalDetails schema type. * + * What to do at the distal point when creating an inhomogeneous + parameter * * @nosubgrouping */ + class DistalDetails: public ::neuroml2::BaseWithoutId { public: /** @@ -36854,6 +40899,7 @@ namespace neuroml2 **segmentGroup** * * @nosubgrouping */ + class Member: public ::neuroml2::BaseWithoutId { public: /** @@ -37014,6 +41060,7 @@ namespace neuroml2 * * @nosubgrouping */ + class Include: public ::neuroml2::BaseWithoutId { public: /** @@ -37175,6 +41222,7 @@ namespace neuroml2 * * @nosubgrouping */ + class Path: public ::neuroml2::BaseWithoutId { public: /** @@ -37431,6 +41479,7 @@ namespace neuroml2 * * @nosubgrouping */ + class SubTree: public ::neuroml2::BaseWithoutId { public: /** @@ -37684,6 +41733,7 @@ namespace neuroml2 * * @nosubgrouping */ + class SegmentEndPoint: public ::neuroml2::BaseWithoutId { public: /** @@ -38502,6 +42552,7 @@ namespace neuroml2 * * @nosubgrouping */ + class MembraneProperties: public ::neuroml2::BaseWithoutId { public: /** @@ -39554,6 +43605,7 @@ namespace neuroml2 * * @nosubgrouping */ + class SpikeThresh: public ::neuroml2::BaseWithoutId { public: /** @@ -39784,6 +43836,7 @@ namespace neuroml2 * * @nosubgrouping */ + class SpecificCapacitance: public ::neuroml2::BaseWithoutId { public: /** @@ -40014,6 +44067,7 @@ namespace neuroml2 * * @nosubgrouping */ + class InitMembPotential: public ::neuroml2::BaseWithoutId { public: /** @@ -40244,6 +44298,7 @@ namespace neuroml2 * * @nosubgrouping */ + class Resistivity: public ::neuroml2::BaseWithoutId { public: /** @@ -44506,6 +48561,7 @@ namespace neuroml2 * * @nosubgrouping */ + class InhomogeneousValue: public ::neuroml2::BaseWithoutId { public: /** @@ -44730,66 +48786,9 @@ namespace neuroml2 * * @nosubgrouping */ + class Species: public ::neuroml2::Base { public: - /** - * @name id - * - * @brief Accessor and modifier functions for the %id - * required attribute. - */ - //@{ - - /** - * @brief Attribute type. - */ - typedef ::neuroml2::NmlId id_type; - - /** - * @brief Attribute traits type. - */ - typedef ::xsd::cxx::tree::traits< id_type, char > id_traits; - - /** - * @brief Return a read-only (constant) reference to the attribute. - * - * @return A constant reference to the attribute. - */ - const id_type& - id () const; - - /** - * @brief Return a read-write reference to the attribute. - * - * @return A reference to the attribute. - */ - id_type& - id (); - - /** - * @brief Set the attribute value. - * - * @param x A new value to set. - * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. - */ - void - id (const id_type& x); - - /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. - */ - void - id (::std::unique_ptr< id_type > p); - - //@} - /** * @name concentrationModel * @@ -45191,7 +49190,6 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< id_type > id_; ::xsd::cxx::tree::one< concentrationModel_type > concentrationModel_; ion_optional ion_; ::xsd::cxx::tree::one< initialConcentration_type > initialConcentration_; @@ -45364,6 +49362,7 @@ namespace neuroml2 * * @nosubgrouping */ + class IntracellularProperties: public ::neuroml2::BaseWithoutId { public: /** @@ -45828,6 +49827,7 @@ namespace neuroml2 * * @nosubgrouping */ + class ExtracellularPropertiesLocal: public ::neuroml2::Base { public: /** @@ -45903,7 +49903,7 @@ namespace neuroml2 * @brief Create an instance from the ultimate base and * initializers for required elements and attributes. */ - ExtracellularPropertiesLocal (); + ExtracellularPropertiesLocal (const id_type&); /** * @brief Create an instance from a DOM element. @@ -52839,6 +56839,82 @@ namespace neuroml2 //@} + /** + * @name neuroLexId + * + * @brief Accessor and modifier functions for the %neuroLexId + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::NeuroLexId neuroLexId_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< neuroLexId_type > neuroLexId_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< neuroLexId_type, char > neuroLexId_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. + */ + const neuroLexId_optional& + neuroLexId () const; + + /** + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. + */ + neuroLexId_optional& + neuroLexId (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + neuroLexId (const neuroLexId_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + neuroLexId (const neuroLexId_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + neuroLexId (::std::unique_ptr< neuroLexId_type > p); + + //@} + /** * @name Constructors */ @@ -52933,6 +57009,7 @@ namespace neuroml2 inputList_sequence inputList_; type_optional type_; temperature_optional temperature_; + neuroLexId_optional neuroLexId_; //@endcond }; @@ -53348,6 +57425,7 @@ namespace neuroml2 * * @nosubgrouping */ + class SpaceStructure: public ::neuroml2::BaseWithoutId { public: /** @@ -54580,6 +58658,82 @@ namespace neuroml2 //@} + /** + * @name neuroLexId + * + * @brief Accessor and modifier functions for the %neuroLexId + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::NeuroLexId neuroLexId_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< neuroLexId_type > neuroLexId_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< neuroLexId_type, char > neuroLexId_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. + */ + const neuroLexId_optional& + neuroLexId () const; + + /** + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. + */ + neuroLexId_optional& + neuroLexId (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + neuroLexId (const neuroLexId_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + neuroLexId (const neuroLexId_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + neuroLexId (::std::unique_ptr< neuroLexId_type > p); + + //@} + /** * @name Constructors */ @@ -54668,6 +58822,7 @@ namespace neuroml2 size_optional size_; type_optional type_; extracellularProperties_optional extracellularProperties_; + neuroLexId_optional neuroLexId_; //@endcond }; @@ -54829,6 +58984,7 @@ namespace neuroml2 * * @nosubgrouping */ + class Layout: public ::neuroml2::BaseWithoutId { public: /** @@ -55236,6 +59392,7 @@ namespace neuroml2 * * @nosubgrouping */ + class UnstructuredLayout: public ::neuroml2::BaseWithoutId { public: /** @@ -55401,6 +59558,7 @@ namespace neuroml2 * * @nosubgrouping */ + class RandomLayout: public ::neuroml2::BaseWithoutId { public: /** @@ -55643,6 +59801,7 @@ namespace neuroml2 * * @nosubgrouping */ + class GridLayout: public ::neuroml2::BaseWithoutId { public: /** @@ -55943,6 +60102,7 @@ namespace neuroml2 * * @nosubgrouping */ + class Instance: public ::neuroml2::BaseWithoutId { public: /** @@ -56381,6 +60541,7 @@ namespace neuroml2 * * @nosubgrouping */ + class Location: public ::neuroml2::BaseWithoutId { public: /** @@ -56790,8 +60951,85 @@ namespace neuroml2 * * @nosubgrouping */ + class SynapticConnection: public ::neuroml2::BaseWithoutId { public: + /** + * @name neuroLexId + * + * @brief Accessor and modifier functions for the %neuroLexId + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::NeuroLexId neuroLexId_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< neuroLexId_type > neuroLexId_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< neuroLexId_type, char > neuroLexId_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. + */ + const neuroLexId_optional& + neuroLexId () const; + + /** + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. + */ + neuroLexId_optional& + neuroLexId (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + neuroLexId (const neuroLexId_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + neuroLexId (const neuroLexId_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + neuroLexId (::std::unique_ptr< neuroLexId_type > p); + + //@} + /** * @name from * @@ -56803,7 +61041,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::xml_schema::string from_type; + typedef ::neuroml2::Nml2PopulationReferencePath from_type; /** * @brief Attribute traits type. @@ -56861,7 +61099,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::xml_schema::string to_type; + typedef ::neuroml2::Nml2PopulationReferencePath to_type; /** * @brief Attribute traits type. @@ -56919,7 +61157,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::xml_schema::string synapse_type; + typedef ::neuroml2::NmlId synapse_type; /** * @brief Attribute traits type. @@ -57125,6 +61363,7 @@ namespace neuroml2 ::xml_schema::flags); protected: + neuroLexId_optional neuroLexId_; ::xsd::cxx::tree::one< from_type > from_; ::xsd::cxx::tree::one< to_type > to_; ::xsd::cxx::tree::one< synapse_type > synapse_; @@ -57670,6 +61909,82 @@ namespace neuroml2 class BaseConnection: public ::neuroml2::BaseNonNegativeIntegerId { public: + /** + * @name neuroLexId + * + * @brief Accessor and modifier functions for the %neuroLexId + * optional attribute. + */ + //@{ + + /** + * @brief Attribute type. + */ + typedef ::neuroml2::NeuroLexId neuroLexId_type; + + /** + * @brief Attribute optional container type. + */ + typedef ::xsd::cxx::tree::optional< neuroLexId_type > neuroLexId_optional; + + /** + * @brief Attribute traits type. + */ + typedef ::xsd::cxx::tree::traits< neuroLexId_type, char > neuroLexId_traits; + + /** + * @brief Return a read-only (constant) reference to the attribute + * container. + * + * @return A constant reference to the optional container. + */ + const neuroLexId_optional& + neuroLexId () const; + + /** + * @brief Return a read-write reference to the attribute container. + * + * @return A reference to the optional container. + */ + neuroLexId_optional& + neuroLexId (); + + /** + * @brief Set the attribute value. + * + * @param x A new value to set. + * + * This function makes a copy of its argument and sets it as + * the new value of the attribute. + */ + void + neuroLexId (const neuroLexId_type& x); + + /** + * @brief Set the attribute value. + * + * @param x An optional container with the new value to set. + * + * If the value is present in @a x then this function makes a copy + * of this value and sets it as the new value of the attribute. + * Otherwise the attribute container is set the 'not present' state. + */ + void + neuroLexId (const neuroLexId_optional& x); + + /** + * @brief Set the attribute value without copying. + * + * @param p A new value to use. + * + * This function will try to use the passed value directly instead + * of making a copy. + */ + void + neuroLexId (::std::unique_ptr< neuroLexId_type > p); + + //@} + /** * @name Constructors */ @@ -57721,6 +62036,17 @@ namespace neuroml2 _clone (::xml_schema::flags f = 0, ::xml_schema::container* c = 0) const; + /** + * @brief Copy assignment operator. + * + * @param x An instance to make a copy of. + * @return A reference to itself. + * + * For polymorphic object models use the @c _clone function instead. + */ + BaseConnection& + operator= (const BaseConnection& x); + //@} /** @@ -57728,8 +62054,30 @@ namespace neuroml2 */ virtual ~BaseConnection (); + + // Implementation. + // + + //@cond + + protected: + void + parse (::xsd::cxx::xml::dom::parser< char >&, + ::xml_schema::flags); + + protected: + neuroLexId_optional neuroLexId_; + + //@endcond }; + bool + operator== (const BaseConnection&, const BaseConnection&); + + bool + operator!= (const BaseConnection&, const BaseConnection&); + + /** * @brief Class corresponding to the %BaseConnectionOldFormat schema type. * @@ -57753,7 +62101,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::xml_schema::string preCellId_type; + typedef ::neuroml2::Nml2PopulationReferencePath preCellId_type; /** * @brief Attribute traits type. @@ -57943,7 +62291,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::xml_schema::string postCellId_type; + typedef ::neuroml2::Nml2PopulationReferencePath postCellId_type; /** * @brief Attribute traits type. @@ -60481,6 +64829,7 @@ namespace neuroml2 * * @nosubgrouping */ + class ExplicitInput: public ::neuroml2::BaseWithoutId { public: /** @@ -60494,7 +64843,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::xml_schema::string target_type; + typedef ::neuroml2::Nml2PopulationReferencePath target_type; /** * @brief Attribute traits type. @@ -60552,7 +64901,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::xml_schema::string input_type; + typedef ::neuroml2::NmlId input_type; /** * @brief Attribute traits type. @@ -60610,7 +64959,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::xml_schema::string destination_type; + typedef ::neuroml2::NmlId destination_type; /** * @brief Attribute optional container type. @@ -61132,66 +65481,9 @@ namespace neuroml2 * * @nosubgrouping */ + class Input: public ::neuroml2::BaseNonNegativeIntegerId { public: - /** - * @name id - * - * @brief Accessor and modifier functions for the %id - * required attribute. - */ - //@{ - - /** - * @brief Attribute type. - */ - typedef ::neuroml2::NonNegativeInteger id_type; - - /** - * @brief Attribute traits type. - */ - typedef ::xsd::cxx::tree::traits< id_type, char > id_traits; - - /** - * @brief Return a read-only (constant) reference to the attribute. - * - * @return A constant reference to the attribute. - */ - const id_type& - id () const; - - /** - * @brief Return a read-write reference to the attribute. - * - * @return A reference to the attribute. - */ - id_type& - id (); - - /** - * @brief Set the attribute value. - * - * @param x A new value to set. - * - * This function makes a copy of its argument and sets it as - * the new value of the attribute. - */ - void - id (const id_type& x); - - /** - * @brief Set the attribute value without copying. - * - * @param p A new value to use. - * - * This function will try to use the passed value directly - * instead of making a copy. - */ - void - id (::std::unique_ptr< id_type > p); - - //@} - /** * @name target * @@ -61203,7 +65495,7 @@ namespace neuroml2 /** * @brief Attribute type. */ - typedef ::xml_schema::string target_type; + typedef ::neuroml2::Nml2PopulationReferencePath target_type; /** * @brief Attribute traits type. @@ -61543,7 +65835,6 @@ namespace neuroml2 ::xml_schema::flags); protected: - ::xsd::cxx::tree::one< id_type > id_; ::xsd::cxx::tree::one< target_type > target_; ::xsd::cxx::tree::one< destination_type > destination_; segmentId_optional segmentId_; @@ -65098,6 +69389,9 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream&, const NeuroLexId&); + ::std::ostream& + operator<< (::std::ostream&, const Nml2PopulationReferencePath&); + ::std::ostream& operator<< (::std::ostream&, const NonNegativeInteger&); @@ -65113,6 +69407,9 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream&, const Notes&); + ::std::ostream& + operator<< (::std::ostream&, const BaseWithoutId&); + ::std::ostream& operator<< (::std::ostream&, const Property&); @@ -65137,6 +69434,9 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream&, const Parameter&); + ::std::ostream& + operator<< (::std::ostream&, const DerivedParameter&); + ::std::ostream& operator<< (::std::ostream&, const LEMS_Property&); @@ -65165,10 +69465,37 @@ namespace neuroml2 operator<< (::std::ostream&, const TimeDerivative&); ::std::ostream& - operator<< (::std::ostream&, const ZeroToOne&); + operator<< (::std::ostream&, const OnStart&); ::std::ostream& - operator<< (::std::ostream&, const BaseWithoutId&); + operator<< (::std::ostream&, const StateAssignment&); + + ::std::ostream& + operator<< (::std::ostream&, const OnEvent&); + + ::std::ostream& + operator<< (::std::ostream&, const EventOut&); + + ::std::ostream& + operator<< (::std::ostream&, const OnCondition&); + + ::std::ostream& + operator<< (::std::ostream&, const Transition&); + + ::std::ostream& + operator<< (::std::ostream&, const Regime&); + + ::std::ostream& + operator<< (::std::ostream&, const OnEntry&); + + ::std::ostream& + operator<< (::std::ostream&, TrueOrFalse::value); + + ::std::ostream& + operator<< (::std::ostream&, const TrueOrFalse&); + + ::std::ostream& + operator<< (::std::ostream&, const ZeroToOne&); ::std::ostream& operator<< (::std::ostream&, const Base&); @@ -65377,6 +69704,9 @@ namespace neuroml2 ::std::ostream& operator<< (::std::ostream&, const PinskyRinzelCA3Cell&); + ::std::ostream& + operator<< (::std::ostream&, const HindmarshRose1984Cell&); + ::std::ostream& operator<< (::std::ostream&, const Cell&); @@ -66226,6 +70556,16 @@ namespace neuroml2 operator<< (::xml_schema::list_stream&, const NeuroLexId&); + void + operator<< (::xercesc::DOMElement&, const Nml2PopulationReferencePath&); + + void + operator<< (::xercesc::DOMAttr&, const Nml2PopulationReferencePath&); + + void + operator<< (::xml_schema::list_stream&, + const Nml2PopulationReferencePath&); + void operator<< (::xercesc::DOMElement&, const NonNegativeInteger&); @@ -66276,6 +70616,16 @@ namespace neuroml2 operator<< (::xml_schema::list_stream&, const Notes&); + void + operator<< (::xercesc::DOMElement&, const BaseWithoutId&); + + void + operator<< (::xercesc::DOMAttr&, const BaseWithoutId&); + + void + operator<< (::xml_schema::list_stream&, + const BaseWithoutId&); + void operator<< (::xercesc::DOMElement&, const Property&); @@ -66300,6 +70650,9 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement&, const Parameter&); + void + operator<< (::xercesc::DOMElement&, const DerivedParameter&); + void operator<< (::xercesc::DOMElement&, const LEMS_Property&); @@ -66327,6 +70680,40 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement&, const TimeDerivative&); + void + operator<< (::xercesc::DOMElement&, const OnStart&); + + void + operator<< (::xercesc::DOMElement&, const StateAssignment&); + + void + operator<< (::xercesc::DOMElement&, const OnEvent&); + + void + operator<< (::xercesc::DOMElement&, const EventOut&); + + void + operator<< (::xercesc::DOMElement&, const OnCondition&); + + void + operator<< (::xercesc::DOMElement&, const Transition&); + + void + operator<< (::xercesc::DOMElement&, const Regime&); + + void + operator<< (::xercesc::DOMElement&, const OnEntry&); + + void + operator<< (::xercesc::DOMElement&, const TrueOrFalse&); + + void + operator<< (::xercesc::DOMAttr&, const TrueOrFalse&); + + void + operator<< (::xml_schema::list_stream&, + const TrueOrFalse&); + void operator<< (::xercesc::DOMElement&, const ZeroToOne&); @@ -66498,9 +70885,6 @@ namespace neuroml2 //@} - void - operator<< (::xercesc::DOMElement&, const BaseWithoutId&); - void operator<< (::xercesc::DOMElement&, const Base&); @@ -66724,6 +71108,9 @@ namespace neuroml2 void operator<< (::xercesc::DOMElement&, const PinskyRinzelCA3Cell&); + void + operator<< (::xercesc::DOMElement&, const HindmarshRose1984Cell&); + void operator<< (::xercesc::DOMElement&, const Cell&); @@ -67104,4 +71491,4 @@ namespace neuroml2 // // End epilogue. -#endif // NEUROML_API_SCHEMA_NEURO_ML_V2_2_HXX +#endif // NEUROML_API_SCHEMA_NEURO_ML_V2_3_HXX diff --git a/src/schema/NeuroML_v2.2.xsd b/src/schema/NeuroML_v2.3.xsd similarity index 87% rename from src/schema/NeuroML_v2.2.xsd rename to src/schema/NeuroML_v2.3.xsd index a5a5461..6106a6f 100644 --- a/src/schema/NeuroML_v2.2.xsd +++ b/src/schema/NeuroML_v2.3.xsd @@ -144,6 +144,15 @@ + + + A path referring to another component. + + + + + + An attribute useful as id of segments, connections, etc: integer >=0 only! @@ -201,18 +210,26 @@ A property ( a **tag** and **value** pair ), which can be on any **baseStandalone** either as a direct child, or within an **Annotation** . Generally something which helps the visual display or facilitates simulation of a Component, but is not a core physiological property. Common examples include: **numberInternalDivisions,** equivalent of nseg in NEURON; **radius,** for a radius to use in graphical displays for abstract cells ( i. e. without defined morphologies ); **color,** the color to use for a **Population** or **populationList** of cells; **recommended_dt_ms,** the recommended timestep to use for simulating a **Network** , **recommended_duration_ms** the recommended duration to use when running a **Network** - - + + + + + + A structured annotation containing metadata, specifically RDF or **property** elements - - - - + + + + + + + + @@ -221,6 +238,7 @@ + @@ -235,31 +253,47 @@ LEMS ComponentType for Constant. - - - - + + + + + + + + LEMS Exposure (ComponentType property) - - - + + + + + + + - - - - + + + + + + + + - - - - + + + + + + + + @@ -267,6 +301,16 @@ + + + LEMS DerivedParamter element + + + + + + + @@ -294,6 +338,10 @@ + + + + @@ -333,6 +381,57 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Float value restricted to between 1 and 0 @@ -404,6 +503,7 @@ + @@ -500,6 +600,7 @@ + @@ -519,6 +620,7 @@ + @@ -597,8 +699,12 @@ - - + + + + + + @@ -917,24 +1023,36 @@ - - - - + + + + + + + + - - - - + + + + + + + + - - - - - - + + + + + + + + + + @@ -1312,7 +1438,8 @@ - + + @@ -1469,23 +1596,23 @@ Cell based on the modified Izhikevich model in Izhikevich 2007, Dynamical systems in neuroscience, MIT Press \n -:param v0: +:param v0: Initial membrane potential :type v0: voltage :param k: :type k: conductance_per_voltage -:param vr: +:param vr: Resting membrane potential :type vr: voltage -:param vt: +:param vt: Spike threshold :type vt: voltage -:param vpeak: +:param vpeak: Peak action potential value :type vpeak: voltage -:param a: +:param a: Time scale of recovery variable u :type a: per_time -:param b: +:param b: Sensitivity of recovery variable u to subthreshold fluctuations of membrane potential v :type b: conductance -:param c: +:param c: After-spike reset value of v :type c: voltage -:param d: +:param d: After-spike increase to u :type d: current :param C: Total capacitance of the cell membrane :type C: capacitance @@ -1510,25 +1637,25 @@ Model based on Brette R and Gerstner W ( 2005 ) Adaptive Exponential Integrate-and-Fire Model as an Effective Description of Neuronal Activity. J Neurophysiol 94:3637-3642 \n -:param gL: +:param gL: Leak conductance :type gL: conductance -:param EL: +:param EL: Leak reversal potential :type EL: voltage -:param VT: +:param VT: Spike threshold :type VT: voltage -:param thresh: +:param thresh: Spike detection threshold :type thresh: voltage -:param reset: +:param reset: Reset potential :type reset: voltage -:param delT: +:param delT: Slope factor :type delT: voltage -:param tauw: +:param tauw: Adaptation time constant :type tauw: time -:param refract: +:param refract: Refractory period :type refract: time -:param a: +:param a: Sub-threshold adaptation variable :type a: conductance -:param b: +:param b: Spike-triggered adaptation variable :type b: current :param C: Total capacitance of the cell membrane :type C: capacitance @@ -1597,7 +1724,7 @@ - Reduced CA3 cell model from Pinsky and Rinzel 1994. See https://github.com/OpenSourceBrain/PinskyRinzelModel + Reduced CA3 cell model from Pinsky, P. F. , Rinzel, J. Intrinsic and network rhythmogenesis in a reduced traub model for CA3 neurons. J Comput Neurosci 1, 39-60 ( 1994 ). See https://github.com/OpenSourceBrain/PinskyRinzelModel \n :param iSoma: :type iSoma: currentDensity @@ -1670,6 +1797,53 @@ + + + The Hindmarsh Rose model is a simplified point cell model which captures complex firing patterns of single neurons, such as periodic and chaotic bursting. It has a fast spiking subsystem, which is a generalization of the FitzHugh-Nagumo system, coupled to a slower subsystem which allows the model to fire bursts. The dynamical variables x, y, z correspond to the membrane potential, a recovery variable, and a slower adaptation current, respectively. See Hindmarsh J. L. , and Rose R. M. ( 1984 ) A model of neuronal bursting using three coupled first order differential equations. Proc. R. Soc. London, Ser. B 221:87–102. +\n +:param a: cubic term in x nullcline +:type a: none +:param b: quadratic term in x nullcline +:type b: none +:param c: constant term in y nullcline +:type c: none +:param d: quadratic term in y nullcline +:type d: none +:param r: timescale separation between slow and fast subsystem ( r greater than 0; r much less than 1 ) +:type r: none +:param s: related to adaptation +:type s: none +:param x1: related to the system's resting potential +:type x1: none +:param v_scaling: scaling of x for physiological membrane potential +:type v_scaling: voltage +:param x0: +:type x0: none +:param y0: +:type y0: none +:param z0: +:type z0: none +:param C: Total capacitance of the cell membrane +:type C: capacitance + + + + + + + + + + + + + + + + + + + Cell with **segment** s specified in a **morphology** element along with details on its **biophysicalProperties** . NOTE: this can only be correctly simulated using jLEMS when there is a single segment in the cell, and **v** of this cell represents the membrane potential in that isopotential segment. @@ -1733,12 +1907,17 @@ + - - + + + + + + @@ -1755,10 +1934,14 @@ - - - - + + + + + + + + @@ -1777,6 +1960,7 @@ + @@ -1805,47 +1989,83 @@ - + + What to do at the proximal point when creating an inhomogeneous parameter + + + + + + + - + + What to do at the distal point when creating an inhomogeneous parameter + + + + + + + A single identified **segment** which is part of the **segmentGroup** - + + + + + Include all members of another **segmentGroup** in this group - + + + + + Include all the **segment** s between those specified by **from** and **to** , inclusive - - - - + + + + + + + + Include all the **segment** s distal to that specified by **from** in the **segmentGroup** - - - - + + + + + + + + - + + + + + @@ -1885,22 +2105,26 @@ Properties specific to the membrane, such as the **populations** of channels, **channelDensities,** **specificCapacitance,** etc. - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + @@ -1925,8 +2149,12 @@ - - + + + + + + @@ -1937,8 +2165,12 @@ - - + + + + + + @@ -1949,8 +2181,12 @@ - - + + + + + + @@ -1961,8 +2197,12 @@ - - + + + + + + @@ -2206,8 +2446,12 @@ Specifies the **value** of an **inhomogeneousParameter.** For usage see **variableParameter** - - + + + + + + @@ -2253,10 +2500,14 @@ Biophysical properties related to the intracellular space within the **cell** , such as the **resistivity** and the list of ionic **species** present. **caConc** and **caConcExt** are explicitly exposed here to facilitate accessing these values from other Components, even though **caConcExt** is clearly not an intracellular property - - - - + + + + + + + + @@ -2281,10 +2532,14 @@ - - - - + + + + + + + + @@ -2717,6 +2972,7 @@ + @@ -2739,16 +2995,20 @@ - - - - - - - - - - + + + + + + + + + + + + + + @@ -2794,6 +3054,7 @@ + @@ -2804,42 +3065,62 @@ - - - - - - + + + + + + + + + + - + + + + + - - + + + + + + - - - - - + + + + + + + + + Specifies a single instance of a component in a **population** ( placed at **location** ). - - - - - - - - - - + + + + + + + + + + + + + + @@ -2854,9 +3135,13 @@ - - - + + + + + + + @@ -2874,10 +3159,15 @@ Explicit event connection between named components, which gets processed via a new instance of a **synapse** component which is created on the target component - - - - + + + + + + + + + @@ -2912,6 +3202,7 @@ + @@ -2922,10 +3213,10 @@ - + - + @@ -3081,9 +3372,13 @@ An explicit input ( anything which extends **basePointCurrent** ) to a target cell in a population - - - + + + + + + + @@ -3106,11 +3401,14 @@ Specifies a single input to a **target,** optionally giving the **segmentId** ( default 0 ) and **fractionAlong** the segment ( default 0. 5 ). - - - - - + + + + + + + + @@ -3623,7 +3921,6 @@ Base element without ID specified *yet*, e.g. for an element with a particular requirement on its id which does not comply with NmlId (e.g. Segment needs nonNegativeInteger). - diff --git a/update.sh b/update.sh index 9906fcb..d51f085 100755 --- a/update.sh +++ b/update.sh @@ -6,9 +6,10 @@ # # Script to regenerate and update the API for a new version of the NeuroML schema # -NEUROML_VERSION="2.2" +NEUROML_VERSION="2.3" echo "Please ensure that you have ctest and xsd installed. See readme for details." +echo "For building documentation doxygen is required also." rm -rf build && \ mkdir build && \