libSBML Perl API  libSBML 5.10.0 Perl API
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Reaction Class Reference
Inheritance diagram for Reaction:
[legend]

Detailed Description

{core} Implementation of SBML's Reaction construct.

A reaction represents any transformation, transport or binding process, typically a chemical reaction, that can change the quantity of one or more species. In SBML, a reaction is defined primarily in terms of the participating reactants and products (and their corresponding stoichiometries), along with optional modifier species, an optional rate at which the reaction takes place, and optional parameters.

As with other major objects in SBML, Reaction has a mandatory attribute, "id", used to give the compartment type an identifier. The identifier must be a text string conforming to the identifer syntax permitted in SBML. In SBML Level 2 and Level 3, the reaction "id" identifier can be used in mathematical formulas elsewhere in an SBML model to represent the rate of that reaction; this usage is explained below. Reaction also has an optional "name" attribute, of type string. The "id" and "name" must be used according to the guidelines described in the SBML specification.

The species participating as reactants, products, and/or modifiers in a reaction are declared using lists of SpeciesReference and/or ModifierSpeciesReference instances stored in subelements "listOfReactants", "listOfProducts" and "listOfModifiers". Certain restrictions are placed on the appearance of species in reaction definitions:

  • The ability of a species to appear as a reactant or product of any reaction in a model is governed by certain flags in that species' definition; see the definition of Species for more information.

  • Any species appearing in the mathematical formula of the subelement "kineticLaw" (described below) of a Reaction must be declared in at least one of that Reaction's lists of reactants, products, and/or modifiers. Put another way, it is an error for a reaction's kinetic law formula to refer to species that have not been declared for that reaction.

  • A reaction definition can contain an empty list of reactants or an empty list of products, but it must have at least one reactant or product; in other words, a reaction without any reactant or product species is not permitted. (This restriction does not apply to modifier species, which remain optional in all cases.)

A reaction can contain up to one KineticLaw object in a subelement named "kineticLaw". It defines the speed at which the process defined by the reaction takes place. The description of KineticLaw provides more details about its use. Note that although the inclusion of a KineticLaw object in an instance of a Reaction component is optional, there is no useful default that can be substituted in place of a missing rate expression in a reaction. Moreover, a reaction's rate cannot be defined in any other way in SBML—InitialAssignment, AssignmentRule, RateRule, AlgebraicRule, Event, and other constructs in SBML cannot be used to set the reaction rate separately. Nevertheless, for some modeling applications, reactions without any defined rate can be perfectly acceptable.

Reaction also has a boolean attribute named "reversible" for indicating whether the reaction is reversible. This attribute is optional in SBML Level 2, with a default of true; it is mandatory in SBML Level 3 (with no default value). To say that a reaction is reversible is to say it can proceed in either the forward or the reverse direction. Although the reversibility of a reaction can sometimes be deduced by inspecting its rate expression, this is not always the case, especially for complicated expressions. Moreover, the need in SBML to allow rate expressions (i.e., KineticLaw) to be optional leads to the need for a separate flag indicating reversibility. Note that labeling a reaction as irreversible is an assertion that the reaction always proceeds in the given forward direction. (Why else would it be flagged as irreversible?) This implies the rate expression in the KineticLaw always has a non-negative value during simulations. Software tools could provide a means of optionally testing that this condition holds. The presence of reversibility information in two places (i.e., the rate expression and the "reversible" attribute on Reaction) leaves open the possibility that a model could contain contradictory information, but the creation of such a model would be an error on the part of the software generating it.

The Reaction object class has another boolean attribute called "fast". This attribute is optional in SBML Level 2, with a default of false; it is mandatory in SBML Level 3 (with no default value). It is used to indicate that a reaction occurs on a vastly faster time scale thanothers in a system. Readers are directed to the SBML Level 2 Version 4 specification, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense. The attribute's default value is false. SBML Level 1 and Level 2 Version 1 incorrectly claimed that software tools could ignore this attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and "fast" cannot be ignored if it is set to true. SBML Level 2 Versions 2–4 therefore stipulate that if a model has any reactions with "fast" set to true, a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Analysis software cannot ignore the value of the "fast" attribute because doing so may lead to different results as compared to a software system that does make use of "fast".

In SBML Level 3 Version 1, the Reaction object has an additional optional attribute named "compartment", whose value must be the identifier of a compartment defined in the enclosing Model object. The "compartment" attribute can be used to indicate the compartment in which the reaction is assumed to take place. If the attribute is present, its value must be the identifier of a Compartment object defined in the enclosing Model object. Similar to the "reversible" attribute, the value of the "compartment" attribute has no direct impact on the construction of mathematical equations for the SBML model. When a kinetic law is given for a reaction, the compartment location may already be implicit in the kinetic law (although this cannot always be guaranteed). Nevertheless, software tools may find the "compartment" attribute value useful for such purposes as analyzing the structure of the model, guiding the modeler in constructing correct rate formulas, and visualization purposes.

Readers are urged to read the SBML specification for more details about the proper use of Reaction.

Examples:
addingEvidenceCodes_1.cpp, createExampleSBML.cpp, printAnnotation.cpp, printMath.cpp, printNotes.cpp, printUnits.cpp, unsetAnnotation.cpp, and unsetNotes.cpp.

Public Member Functions

virtual bool accept (SBMLVisitor &v) const
 Accepts the given SBMLVisitor for this instance of Reaction. More...
 
int addCVTerm (CVTerm *term, bool newBag=false)
 Adds a copy of the given CVTerm object to this SBML object. More...
 
int addModifier (const ModifierSpeciesReference *msr)
 Adds a given ModifierSpeciesReference object as a product in this Reaction. More...
 
int addProduct (const SpeciesReference *sr)
 Adds a given SpeciesReference object as a product in this Reaction. More...
 
int addReactant (const SpeciesReference *sr)
 Adds a given SpeciesReference object as a reactant in this Reaction. More...
 
virtual int appendAnnotation (const XMLNode *annotation)
 Appends the given annotation to the "annotation" subelement of this object. More...
 
virtual int appendAnnotation (const std::string &annotation)
 Appends the given annotation to the "annotation" subelement of this object. More...
 
int appendNotes (const XMLNode *notes)
 Appends the given notes to the "notes" subelement of this object. More...
 
int appendNotes (const std::string &notes)
 Appends the given notes to the "notes" subelement of this object. More...
 
virtual Reactionclone () const
 Creates and returns a deep copy of this Reaction. More...
 
KineticLawcreateKineticLaw ()
 Creates a new KineticLaw object, installs it as this Reaction's "kineticLaw" subelement, and returns it. More...
 
ModifierSpeciesReferencecreateModifier ()
 Creates a new ModifierSpeciesReference, adds it to this Reaction's list of modifiers and returns it. More...
 
SpeciesReferencecreateProduct ()
 Creates a new SpeciesReference, adds it to this Reaction's list of products, and returns it. More...
 
SpeciesReferencecreateReactant ()
 Creates a new SpeciesReference, adds it to this Reaction's list of reactants, and returns it. More...
 
int disablePackage (const std::string &pkgURI, const std::string &pkgPrefix)
 Disables the given SBML Level 3 package on this object. More...
 
int enablePackage (const std::string &pkgURI, const std::string &pkgPrefix, bool flag)
 Enables or disables the given SBML Level 3 package on this object. More...
 
virtual ListgetAllElements (ElementFilter *filter=NULL)
 Returns a List of all child SBase objects, including those nested to an arbitrary depth. More...
 
virtual ListgetAllElementsFromPlugins (ElementFilter *filter=NULL)
 Returns a List of all child SBase objects contained in SBML package plug-ins. More...
 
SBasegetAncestorOfType (int type, const std::string pkgName="core")
 Returns the first ancestor object that has the given SBML type code from the given package. More...
 
const SBasegetAncestorOfType (int type, const std::string pkgName="core") const
 Returns the first ancestor object that has the given SBML type code from the given package. More...
 
XMLNodegetAnnotation ()
 Returns the content of the "annotation" subelement of this object as a tree of XMLNode objects. More...
 
XMLNodegetAnnotation () const
 Returns the content of the "annotation" subelement of this object as a tree of XMLNode objects. More...
 
std::string getAnnotationString ()
 Returns the content of the "annotation" subelement of this object as a character string. More...
 
std::string getAnnotationString () const
 Returns the content of the "annotation" subelement of this object as a character string. More...
 
unsigned int getColumn () const
 Returns the column number on which this object first appears in the XML representation of the SBML document. More...
 
const std::string & getCompartment () const
 (SBML Level 3 only) Returns the value of the "compartment" attribute on the Reaction. More...
 
CVTermgetCVTerm (unsigned int n)
 Returns the nth CVTerm in the list of CVTerms of this SBML object. More...
 
ListgetCVTerms ()
 Returns a list of CVTerm objects in the annotations of this SBML object. More...
 
ListgetCVTerms () const
 Returns a list of CVTerm objects in the annotations of this SBML object. More...
 
virtual SBasegetElementByMetaId (const std::string &metaid)
 Returns the first child element it can find with the given metaid, or NULL if no such object is found. More...
 
virtual SBasegetElementBySId (const std::string &id)
 Returns the first child element found that has the given id in the model-wide SId namespace, or NULL if no such object is found. More...
 
virtual const std::string & getElementName () const
 Returns the XML element name of this object, which for Reaction, is always "reaction". More...
 
bool getFast () const
 Returns the value of the "fast" attribute of this Reaction. More...
 
virtual const std::string & getId () const
 Returns the value of the "id" attribute of this Reaction. More...
 
const KineticLawgetKineticLaw () const
 Returns the KineticLaw object contained in this Reaction. More...
 
KineticLawgetKineticLaw ()
 Returns the KineticLaw object contained in this Reaction. More...
 
unsigned int getLevel () const
 Returns the SBML Level of the SBMLDocument object containing this object. More...
 
unsigned int getLine () const
 Returns the line number on which this object first appears in the XML representation of the SBML document. More...
 
const ListOfSpeciesReferencesgetListOfModifiers () const
 Returns the list of modifiers in this Reaction object. More...
 
ListOfSpeciesReferencesgetListOfModifiers ()
 Returns the list of modifiers in this Reaction object. More...
 
const ListOfSpeciesReferencesgetListOfProducts () const
 Returns the list of products in this Reaction object. More...
 
ListOfSpeciesReferencesgetListOfProducts ()
 Returns the list of products in this Reaction object. More...
 
const ListOfSpeciesReferencesgetListOfReactants () const
 Returns the list of reactants in this Reaction object. More...
 
ListOfSpeciesReferencesgetListOfReactants ()
 Returns the list of reactants in this Reaction object. More...
 
const std::string & getMetaId () const
 Returns the value of the "metaid" attribute of this object. More...
 
std::string & getMetaId ()
 Returns the value of the "metaid" attribute of this object. More...
 
const ModelgetModel () const
 Returns the Model object for the SBML Document in which the current object is located. More...
 
ModelHistorygetModelHistory () const
 Returns the ModelHistory object, if any, attached to this object. More...
 
ModelHistorygetModelHistory ()
 Returns the ModelHistory object, if any, attached to this object. More...
 
const ModifierSpeciesReferencegetModifier (unsigned int n) const
 Returns the nth modifier species (as a ModifierSpeciesReference object) in the list of modifiers of this Reaction. More...
 
ModifierSpeciesReferencegetModifier (unsigned int n)
 Returns the nth modifier species (as a ModifierSpeciesReference object) in the list of modifiers of this Reaction. More...
 
const ModifierSpeciesReferencegetModifier (const std::string &species) const
 Returns the modifier species (as a ModifierSpeciesReference object) having a specific identifier in this Reaction. More...
 
ModifierSpeciesReferencegetModifier (const std::string &species)
 Returns the modifier species (as a ModifierSpeciesReference object) having a specific identifier in this Reaction. More...
 
virtual const std::string & getName () const
 Returns the value of the "name" attribute of this Reaction. More...
 
virtual XMLNamespacesgetNamespaces () const
 Returns a list of the XML Namespaces declared on this SBML document. More...
 
XMLNodegetNotes ()
 Returns the content of the "notes" subelement of this object as a tree of XMLNode objects. More...
 
XMLNodegetNotes () const
 Returns the content of the "notes" subelement of this object as a tree of XMLNode objects. More...
 
std::string getNotesString ()
 Returns the content of the "notes" subelement of this object as a string. More...
 
std::string getNotesString () const
 Returns the content of the "notes" subelement of this object as a string. More...
 
unsigned int getNumCVTerms ()
 Returns the number of CVTerm objects in the annotations of this SBML object. More...
 
unsigned int getNumModifiers () const
 Returns the number of modifier species in this Reaction. More...
 
unsigned int getNumPlugins () const
 Returns the number of plug-in objects (extenstion interfaces) for SBML Level 3 package extensions known. More...
 
unsigned int getNumProducts () const
 Returns the number of product species in this Reaction. More...
 
unsigned int getNumReactants () const
 Returns the number of reactant species in this Reaction. More...
 
const std::string & getPackageName () const
 Returns the name of the SBML Level 3 package in which this element is defined. More...
 
unsigned int getPackageVersion () const
 Returns the Version of the SBML Level 3 package to which this element belongs to. More...
 
SBasegetParentSBMLObject ()
 Returns the parent SBML object containing this object. More...
 
const SBasegetParentSBMLObject () const
 Returns the parent SBML object containing this object. More...
 
SBasePlugingetPlugin (const std::string &package)
 Returns a plug-in object (extension interface) for an SBML Level 3 package extension with the given package name or URI. More...
 
const SBasePlugingetPlugin (const std::string &package) const
 Returns a plug-in object (extension interface) for an SBML Level 3 package extension with the given package name or URI. More...
 
SBasePlugingetPlugin (unsigned int n)
 Returns the nth plug-in object (extension interface) for an SBML Level 3 package extension. More...
 
const SBasePlugingetPlugin (unsigned int n) const
 Returns the nth plug-in object (extension interface) for an SBML Level 3 package extension. More...
 
std::string getPrefix () const
 Returns the namespace prefix of this element. More...
 
const SpeciesReferencegetProduct (unsigned int n) const
 Returns the nth product species (as a SpeciesReference object) in the list of products in this Reaction. More...
 
SpeciesReferencegetProduct (unsigned int n)
 Returns the nth product species (as a SpeciesReference object) in the list of products in this Reaction. More...
 
const SpeciesReferencegetProduct (const std::string &species) const
 Returns the product species (as a SpeciesReference object) having a specific identifier in this Reaction. More...
 
SpeciesReferencegetProduct (const std::string &species)
 Returns the product species (as a SpeciesReference object) having a specific identifier in this Reaction. More...
 
const SpeciesReferencegetReactant (unsigned int n) const
 Returns the nth reactant species (as a SpeciesReference object) in the list of reactants in this Reaction. More...
 
SpeciesReferencegetReactant (unsigned int n)
 Returns the nth reactant species (as a SpeciesReference object) in the list of reactants in this Reaction. More...
 
const SpeciesReferencegetReactant (const std::string &species) const
 Returns the reactant species (as a SpeciesReference object) having a specific identifier in this Reaction. More...
 
SpeciesReferencegetReactant (const std::string &species)
 Returns the reactant species (as a SpeciesReference object) having a specific identifier in this Reaction. More...
 
BiolQualifierType_t getResourceBiologicalQualifier (std::string resource)
 Returns the MIRIAM biological qualifier associated with the given resource. More...
 
ModelQualifierType_t getResourceModelQualifier (std::string resource)
 Returns the MIRIAM model qualifier associated with the given resource. More...
 
bool getReversible () const
 Returns the value of the "reversible" attribute on the Reaction as a boolean value. More...
 
const SBMLDocumentgetSBMLDocument () const
 Returns the SBMLDocument object containing this object instance. More...
 
SBMLDocumentgetSBMLDocument ()
 Returns the SBMLDocument object containing this object instance. More...
 
int getSBOTerm () const
 Returns the integer portion of the value of the "sboTerm" attribute of this object. More...
 
std::string getSBOTermAsURL () const
 Returns the identifiers.org URL representation of the "sboTerm" attribute of this object. More...
 
std::string getSBOTermID () const
 Returns the string representation of the "sboTerm" attribute of this object. More...
 
virtual int getTypeCode () const
 Returns the libSBML type code for this SBML object. More...
 
std::string getURI () const
 Gets the namespace URI to which this element belongs to. More...
 
void * getUserData () const
 Returns the user data that has been previously set via setUserData(). More...
 
unsigned int getVersion () const
 Returns the Version within the SBML Level of the SBMLDocument object containing this object. More...
 
virtual bool hasRequiredAttributes () const
 Predicate returning true if all the required attributes for this Reaction object have been set. More...
 
bool hasValidLevelVersionNamespaceCombination ()
 Predicate returning true if this object's level/version and namespace values correspond to a valid SBML specification. More...
 
void initDefaults ()
 Initializes the fields of this Reaction object to "typical" default values. More...
 
bool isPackageEnabled (const std::string &pkgName) const
 Predicate returning true if the given SBML Level 3 package is enabled with this object. More...
 
bool isPackageURIEnabled (const std::string &pkgURI) const
 Predicate returning true if an SBML Level 3 package with the given URI is enabled with this object. More...
 
bool isPkgEnabled (const std::string &pkgName) const
 Predicate returning true if the given SBML Level 3 package is enabled with this object. More...
 
bool isPkgURIEnabled (const std::string &pkgURI) const
 Predicate returning true if an SBML Level 3 package with the given URI is enabled with this object. More...
 
bool isSetAnnotation () const
 Predicate returning true if this object's "annotation" subelement exists and has content. More...
 
bool isSetCompartment () const
 Predicate returning true if this Reaction's "compartment" attribute is set. More...
 
bool isSetFast () const
 Predicate returning true if the value of the "fast" attribute on this Reaction. More...
 
virtual bool isSetId () const
 Predicate returning true if this Reaction's "id" attribute is set. More...
 
bool isSetKineticLaw () const
 Predicate returning true if this Reaction contains a kinetic law object. More...
 
bool isSetMetaId () const
 Predicate returning true if this object's "metaid" attribute is set. More...
 
bool isSetModelHistory ()
 Predicate returning true if this object has a ModelHistory object attached to it. More...
 
virtual bool isSetName () const
 Predicate returning true if this Reaction's "name" attribute is set. More...
 
bool isSetNotes () const
 Predicate returning true if this object's "notes" subelement exists and has content. More...
 
bool isSetReversible () const
 Predicate returning true if this Reaction's "reversible" attribute is set. More...
 
bool isSetSBOTerm () const
 Predicate returning true if this object's "sboTerm" attribute is set. More...
 
bool matchesRequiredSBMLNamespacesForAddition (const SBase *sb)
 Returns true if this object's set of XML namespaces are a subset of the given object's XML namespaces. More...
 
bool matchesRequiredSBMLNamespacesForAddition (const SBase *sb) const
 Returns true if this object's set of XML namespaces are a subset of the given object's XML namespaces. More...
 
bool matchesSBMLNamespaces (const SBase *sb)
 Returns true if this object's set of XML namespaces are the same as the given object's XML namespaces. More...
 
bool matchesSBMLNamespaces (const SBase *sb) const
 Returns true if this object's set of XML namespaces are the same as the given object's XML namespaces. More...
 
Reactionoperator= (const Reaction &rhs)
 Assignment operator for Reaction. More...
 
 Reaction (unsigned int level, unsigned int version)
 Creates a new Reaction using the given SBML level and version values. More...
 
 Reaction (SBMLNamespaces *sbmlns)
 Creates a new Reaction using the given SBMLNamespaces object sbmlns. More...
 
 Reaction (const Reaction &orig)
 Copy constructor; creates a copy of this Reaction. More...
 
void read (XMLNode &node, XMLErrorSeverityOverride_t flag=LIBSBML_OVERRIDE_DISABLED)
 Reads (initializes) this SBML object by reading from the given XMLNode. More...
 
virtual int removeFromParentAndDelete ()
 Removes this object from its parent. More...
 
ModifierSpeciesReferenceremoveModifier (unsigned int n)
 Removes the nth modifier species (ModifierSpeciesReference object) in the list of modifiers in this Reaction and returns a pointer to it. More...
 
ModifierSpeciesReferenceremoveModifier (const std::string &species)
 Removes the modifier species (ModifierSpeciesReference object) having the given "species" attribute in this Reaction and returns a pointer to it. More...
 
SpeciesReferenceremoveProduct (unsigned int n)
 Removes the nth product species (SpeciesReference object) in the list of products in this Reaction and returns a pointer to it. More...
 
SpeciesReferenceremoveProduct (const std::string &species)
 Removes the product species (SpeciesReference object) having the given "species" attribute in this Reaction and returns a pointer to it. More...
 
SpeciesReferenceremoveReactant (unsigned int n)
 Removes the nth reactant species (SpeciesReference object) in the list of reactants in this Reaction and returns a pointer to it. More...
 
SpeciesReferenceremoveReactant (const std::string &species)
 Removes the reactant species (SpeciesReference object) having the given "species" attribute in this Reaction and returns a pointer to it. More...
 
int removeTopLevelAnnotationElement (const std::string elementName, const std::string elementURI="", bool removeEmpty=true)
 Removes the top-level element within the "annotation" subelement of this SBML object with the given name and optional URI. More...
 
virtual void renameMetaIdRefs (const std::string &oldid, const std::string &newid)
 Renames all the meta-identifier attributes on this element. More...
 
virtual void renameSIdRefs (const std::string &oldid, const std::string &newid)
 Renames all the SIdRef attributes on this element, including any found in MathML. More...
 
virtual void renameUnitSIdRefs (const std::string &oldid, const std::string &newid)
 Renames all the UnitSIdRef attributes on this element. More...
 
int replaceTopLevelAnnotationElement (const XMLNode *annotation)
 Replaces the given top-level element within the "annotation" subelement of this SBML object and with the annotation element supplied. More...
 
int replaceTopLevelAnnotationElement (const std::string &annotation)
 Replaces the given top-level element within the "annotation" subelement of this SBML object and with the annotation element supplied. More...
 
virtual int setAnnotation (const XMLNode *annotation)
 Sets the value of the "annotation" subelement of this SBML object. More...
 
virtual int setAnnotation (const std::string &annotation)
 Sets the value of the "annotation" subelement of this SBML object. More...
 
int setCompartment (const std::string &sid)
 Sets the value of the "compartment" attribute of this Reaction. More...
 
int setFast (bool value)
 Sets the value of the "fast" attribute of this Reaction. More...
 
virtual int setId (const std::string &sid)
 Sets the value of the "id" attribute of this Reaction. More...
 
int setKineticLaw (const KineticLaw *kl)
 Sets the "kineticLaw" subelement of this Reaction to a copy of the given KineticLaw object. More...
 
int setMetaId (const std::string &metaid)
 Sets the value of the meta-identifier attribute of this object. More...
 
int setModelHistory (ModelHistory *history)
 Sets the ModelHistory of this object. More...
 
virtual int setName (const std::string &name)
 Sets the value of the "name" attribute of this Reaction. More...
 
int setNamespaces (XMLNamespaces *xmlns)
 Sets the namespaces relevant of this SBML object. More...
 
int setNotes (const XMLNode *notes)
 Sets the value of the "notes" subelement of this SBML object. More...
 
int setNotes (const std::string &notes, bool addXHTMLMarkup=false)
 Sets the value of the "notes" subelement of this SBML object to a copy of the string notes. More...
 
int setReversible (bool value)
 Sets the value of the "reversible" attribute of this Reaction. More...
 
virtual int setSBOTerm (int value)
 Sets the value of the "sboTerm" attribute. More...
 
virtual int setSBOTerm (const std::string &sboid)
 Sets the value of the "sboTerm" attribute by string. More...
 
int setUserData (void *userData)
 Sets the user data of this element. More...
 
char * toSBML ()
 Returns a string consisting of a partial SBML corresponding to just this object. More...
 
XMLNodetoXMLNode ()
 Returns this element as an XMLNode. More...
 
int unsetAnnotation ()
 Unsets the value of the "annotation" subelement of this SBML object. More...
 
int unsetCompartment ()
 Unsets the value of the "compartment" attribute of this Reaction. More...
 
int unsetCVTerms ()
 Clears the list of CVTerm objects attached to this SBML object. More...
 
int unsetFast ()
 Unsets the value of the "fast" attribute of this Reaction. More...
 
virtual int unsetId ()
 Unsets the value of the "id" attribute of this SBML object. More...
 
int unsetKineticLaw ()
 Unsets the "kineticLaw" subelement of this Reaction. More...
 
int unsetMetaId ()
 Unsets the value of the "metaid" attribute of this SBML object. More...
 
int unsetModelHistory ()
 Unsets the ModelHistory object attached to this object. More...
 
virtual int unsetName ()
 Unsets the value of the "name" attribute of this Reaction. More...
 
int unsetNotes ()
 Unsets the value of the "notes" subelement of this SBML object. More...
 
int unsetSBOTerm ()
 Unsets the value of the "sboTerm" attribute of this SBML object. More...
 
virtual ~Reaction ()
 Destroys this Reaction. More...
 

Protected Member Functions

virtual void setElementText (const std::string &text)
 When overridden allows SBase elements to use the text included in between the elements tags. More...
 

Constructor & Destructor Documentation

Reaction::Reaction ( unsigned int  level,
unsigned int  version 
)

Creates a new Reaction using the given SBML level and version values.

Parameters
levelan unsigned int, the SBML Level to assign to this Reaction
versionan unsigned int, the SBML Version to assign to this Reaction
Exceptions
SBMLConstructorExceptionThrown if the given level and version combination, or this kind of SBML object, are either invalid or mismatched with respect to the parent SBMLDocument object.
Note
Upon the addition of a Reaction object to an SBMLDocument (e.g., using Model::addReaction()), the SBML Level, SBML Version and XML namespace of the document override the values used when creating the Reaction object via this constructor. This is necessary to ensure that an SBML document is a consistent structure. Nevertheless, the ability to supply the values at the time of creation of a Reaction is an important aid to producing valid SBML. Knowledge of the intented SBML Level and Version determine whether it is valid to assign a particular value to an attribute, or whether it is valid to add an object to an existing SBMLDocument.
Reaction::Reaction ( SBMLNamespaces sbmlns)

Creates a new Reaction using the given SBMLNamespaces object sbmlns.

The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments.
Parameters
sbmlnsan SBMLNamespaces object.
Exceptions
SBMLConstructorExceptionThrown if the given level and version combination, or this kind of SBML object, are either invalid or mismatched with respect to the parent SBMLDocument object.
Note
Upon the addition of a Reaction object to an SBMLDocument (e.g., using Model::addReaction()), the SBML Level, SBML Version and XML namespace of the document override the values used when creating the Reaction object via this constructor. This is necessary to ensure that an SBML document is a consistent structure. Nevertheless, the ability to supply the values at the time of creation of a Reaction is an important aid to producing valid SBML. Knowledge of the intented SBML Level and Version determine whether it is valid to assign a particular value to an attribute, or whether it is valid to add an object to an existing SBMLDocument.
Reaction::~Reaction ( )
virtual

Destroys this Reaction.

Reaction::Reaction ( const Reaction orig)

Copy constructor; creates a copy of this Reaction.

Parameters
origthe object to copy.
Exceptions
SBMLConstructorExceptionThrown if the argument orig is NULL.

Member Function Documentation

bool Reaction::accept ( SBMLVisitor v) const
virtual

Accepts the given SBMLVisitor for this instance of Reaction.

Parameters
vthe SBMLVisitor instance to be used.
Returns
the result of calling v.visit().

Implements SBase.

int SBase::addCVTerm ( CVTerm term,
bool  newBag = false 
)
inherited

Adds a copy of the given CVTerm object to this SBML object.

Parameters
termthe CVTerm to assign.
newBagif true, creates a new RDF bag with the same identifier as a previous bag, and if false, adds the term to an existing RDF bag with the same type of qualifier as the term being added.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
Since the CV Term uses the "metaid" attribute of the object as a reference, if the object has no "metaid" attribute value set, then the CVTerm will not be added.
This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues.
Documentation note:
The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation.
Examples:
addCVTerms.cpp, addingEvidenceCodes_1.cpp, and addingEvidenceCodes_2.cpp.
int Reaction::addModifier ( const ModifierSpeciesReference msr)

Adds a given ModifierSpeciesReference object as a product in this Reaction.

The ModifierSpeciesReference instance in msr is copied.

Parameters
msra ModifierSpeciesReference object referring to a Species in the enclosing Model
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues.
See also
createModifier()
int Reaction::addProduct ( const SpeciesReference sr)

Adds a given SpeciesReference object as a product in this Reaction.

The SpeciesReference instance in sr is copied.

Parameters
sra SpeciesReference object referring to a Species in the enclosing Model
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues.
See also
createProduct()
int Reaction::addReactant ( const SpeciesReference sr)

Adds a given SpeciesReference object as a reactant in this Reaction.

The SpeciesReference instance in sr is copied.

Parameters
sra SpeciesReference object referring to a Species in the enclosing Model
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
This method should be used with some caution. The fact that this method copies the object passed to it means that the caller will be left holding a physically different object instance than the one contained inside this object. Changes made to the original object instance (such as resetting attribute values) will not affect the instance in this object. In addition, the caller should make sure to free the original object if it is no longer being used, or else a memory leak will result. Please see other methods on this class (particularly a corresponding method whose name begins with the word create) for alternatives that do not lead to these issues.
See also
createReactant()
int SBase::appendAnnotation ( const XMLNode annotation)
virtualinherited

Appends the given annotation to the "annotation" subelement of this object.

Whereas the SBase "notes" subelement is a container for content to be shown directly to humans, the "annotation" element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for "annotation". The element's content type is XML type "any", allowing essentially arbitrary well-formed XML data content.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

Unlike SBase::setAnnotation(const XMLNode* annotation) or SBase::setAnnotation(const std::string& annotation), this method allows other annotations to be preserved when an application adds its own data.

Parameters
annotationan XML structure that is to be copied and appended to the content of the "annotation" subelement of this object
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
getAnnotationString()
isSetAnnotation()
setAnnotation(const XMLNode* annotation)
setAnnotation(const std::string& annotation)
appendAnnotation(const std::string& annotation)
unsetAnnotation()

Reimplemented in Model, and SpeciesReference.

Examples:
addingEvidenceCodes_2.cpp, and appendAnnotation.cpp.
int SBase::appendAnnotation ( const std::string &  annotation)
virtualinherited

Appends the given annotation to the "annotation" subelement of this object.

Whereas the SBase "notes" subelement is a container for content to be shown directly to humans, the "annotation" element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for "annotation". The element's content type is XML type "any", allowing essentially arbitrary well-formed XML data content.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

Unlike SBase::setAnnotation(const XMLNode* annotation) or SBase::setAnnotation(const std::string& annotation), this method allows other annotations to be preserved when an application adds its own data.

Parameters
annotationan XML string that is to be copied and appended to the content of the "annotation" subelement of this object
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
getAnnotationString()
isSetAnnotation()
setAnnotation(const XMLNode* annotation)
setAnnotation(const std::string& annotation)
appendAnnotation(const XMLNode* annotation)
unsetAnnotation()

Reimplemented in Model, and SpeciesReference.

int SBase::appendNotes ( const XMLNode notes)
inherited

Appends the given notes to the "notes" subelement of this object.

The content of notes is copied.

The optional SBML element named "notes", present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the "notes" element would be to contain formatted user comments about the model element in which the "notes" element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for "notes", allowing users considerable freedom when adding comments to their models.

The format of "notes" elements must be XHTML 1.0. To help verify the formatting of "notes" content, libSBML provides the static utility method SyntaxChecker::hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and  3 specifications have considerable detail about how "notes" element content must be structured.

Parameters
notesan XML node structure that is to appended to the content of the "notes" subelement of this object
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
getNotesString()
isSetNotes()
setNotes(const XMLNode* notes)
setNotes(const std::string& notes, bool addXHTMLMarkup)
appendNotes(const std::string& notes)
unsetNotes()
SyntaxChecker::hasExpectedXHTMLSyntax()
int SBase::appendNotes ( const std::string &  notes)
inherited

Appends the given notes to the "notes" subelement of this object.

The content of the parameter notes is copied.

The optional SBML element named "notes", present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the "notes" element would be to contain formatted user comments about the model element in which the "notes" element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for "notes", allowing users considerable freedom when adding comments to their models.

The format of "notes" elements must be XHTML 1.0. To help verify the formatting of "notes" content, libSBML provides the static utility method SyntaxChecker::hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and  3 specifications have considerable detail about how "notes" element content must be structured.

Parameters
notesan XML string that is to appended to the content of the "notes" subelement of this object
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
getNotesString()
isSetNotes()
setNotes(const XMLNode* notes)
setNotes(const std::string& notes, bool addXHTMLMarkup)
appendNotes(const XMLNode* notes)
unsetNotes()
SyntaxChecker::hasExpectedXHTMLSyntax()
Reaction * Reaction::clone ( ) const
virtual

Creates and returns a deep copy of this Reaction.

Returns
a (deep) copy of this Reaction.

Implements SBase.

KineticLaw * Reaction::createKineticLaw ( )

Creates a new KineticLaw object, installs it as this Reaction's "kineticLaw" subelement, and returns it.

If this Reaction had a previous KineticLaw, it will be destroyed.

Returns
the new KineticLaw object
Examples:
createExampleSBML.cpp.
ModifierSpeciesReference * Reaction::createModifier ( )

Creates a new ModifierSpeciesReference, adds it to this Reaction's list of modifiers and returns it.

Returns
a new ModifierSpeciesReference object.
SpeciesReference * Reaction::createProduct ( )

Creates a new SpeciesReference, adds it to this Reaction's list of products, and returns it.

Returns
a new SpeciesReference object.
Examples:
createExampleSBML.cpp.
SpeciesReference * Reaction::createReactant ( )

Creates a new SpeciesReference, adds it to this Reaction's list of reactants, and returns it.

Returns
a new SpeciesReference object.
Examples:
createExampleSBML.cpp.
int SBase::disablePackage ( const std::string &  pkgURI,
const std::string &  pkgPrefix 
)
inherited

Disables the given SBML Level 3 package on this object.

This method disables the specified package on this object and other objects connected by child-parent links in the same SBMLDocument object.

An example of when this may be useful is during construction of model components when mixing existing and new models. Suppose your application read an SBML document containing a model that used the SBML Hierarchical Model Composition (“comp”) package, and extracted parts of that model in order to construct a new model in memory. The new, in-memory model will not accept a component drawn from another SBMLDocument with different package namespace declarations. You could reconstruct the same namespaces in the in-memory model first, but as a shortcut, you could also disable the package namespace on the object being added. Here is a code example to help clarify this:

Parameters
pkgURIthe URI of the package
pkgPrefixthe XML prefix of the package
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
enablePackage(const std::string& pkgURI, const std::string& pkgPrefix, bool flag)
int SBase::enablePackage ( const std::string &  pkgURI,
const std::string &  pkgPrefix,
bool  flag 
)
inherited

Enables or disables the given SBML Level 3 package on this object.

This method enables the specified package on this object and other objects connected by child-parent links in the same SBMLDocument object. This method is the converse of SBase::disablePackage(const std::string& pkgURI, const std::string& pkgPrefix).

Parameters
pkgURIthe URI of the package.
pkgPrefixthe XML prefix of the package
flagwhether to enable (true) or disable (false) the package
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
disablePackage(const std::string& pkgURI, const std::string& pkgPrefix)
List * Reaction::getAllElements ( ElementFilter *  filter = NULL)
virtual

Returns a List of all child SBase objects, including those nested to an arbitrary depth.

Returns
a List of pointers to all children objects.

Reimplemented from SBase.

List * SBase::getAllElementsFromPlugins ( ElementFilter *  filter = NULL)
virtualinherited

Returns a List of all child SBase objects contained in SBML package plug-ins.

SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages.

This method walks down the list of all SBML Level 3 packages used by this object and returns all child objects defined by those packages.

Returns
a pointer to a List of pointers to all children objects from plug-ins.
SBase * SBase::getAncestorOfType ( int  type,
const std::string  pkgName = "core" 
)
inherited

Returns the first ancestor object that has the given SBML type code from the given package.

This method searches the tree of objects that are parents of this object, and returns the first one that has the given SBML type code from the given pkgName.

Parameters
typethe SBML type code of the object sought
pkgName(optional) the short name of an SBML Level 3 package to which the sought-after object must belong
Returns
the ancestor SBML object of this SBML object that corresponds to the given SBML object type code, or NULL if no ancestor exists.
Warning
The optional argument pkgName must be used for all type codes from SBML Level 3 packages. Otherwise, the function will search the "core" namespace alone, not find any corresponding elements, and return NULL.
Documentation note:
The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation.
const SBase * SBase::getAncestorOfType ( int  type,
const std::string  pkgName = "core" 
) const
inherited

Returns the first ancestor object that has the given SBML type code from the given package.

This method searches the tree of objects that are parents of this object, and returns the first one that has the given SBML type code from the given pkgName.

Parameters
typethe SBML type code of the object sought
pkgName(optional) the short name of an SBML Level 3 package to which the sought-after object must belong
Returns
the ancestor SBML object of this SBML object that corresponds to the given SBML object type code, or NULL if no ancestor exists.
Warning
The optional argument pkgName must be used for all type codes from SBML Level 3 packages. Otherwise, the function will search the "core" namespace alone, not find any corresponding elements, and return NULL.
Documentation note:
The native C++ implementation of this method defines a default argument value. In the documentation generated for different libSBML language bindings, you may or may not see corresponding arguments in the method declarations. For example, in Java and C#, a default argument is handled by declaring two separate methods, with one of them having the argument and the other one lacking the argument. However, the libSBML documentation will be identical for both methods. Consequently, if you are reading this and do not see an argument even though one is described, please look for descriptions of other variants of this method near where this one appears in the documentation.
XMLNode * SBase::getAnnotation ( )
inherited

Returns the content of the "annotation" subelement of this object as a tree of XMLNode objects.

Whereas the SBML "notes" subelement is a container for content to be shown directly to humans, the "annotation" element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for "annotation". The element's content type is XML type "any", allowing essentially arbitrary well-formed XML data content.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

The annotations returned by this method will be in XML form. LibSBML provides an object model and related interfaces for certain specific kinds of annotations, namely model history information and RDF content. See the ModelHistory, CVTerm and RDFAnnotationParser classes for more information about the facilities available.

Returns
the annotation of this SBML object as a tree of XMLNode objects.
See also
getAnnotationString()
isSetAnnotation()
setAnnotation(const XMLNode* annotation)
setAnnotation(const std::string& annotation)
appendAnnotation(const XMLNode* annotation)
appendAnnotation(const std::string& annotation)
unsetAnnotation()
XMLNode * SBase::getAnnotation ( ) const
inherited

Returns the content of the "annotation" subelement of this object as a tree of XMLNode objects.

Whereas the SBML "notes" subelement is a container for content to be shown directly to humans, the "annotation" element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for "annotation". The element's content type is XML type "any", allowing essentially arbitrary well-formed XML data content.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

The annotations returned by this method will be in XML form. LibSBML provides an object model and related interfaces for certain specific kinds of annotations, namely model history information and RDF content. See the ModelHistory, CVTerm and RDFAnnotationParser classes for more information about the facilities available.

Returns
the annotation of this SBML object as a tree of XMLNode objects.
See also
getAnnotationString()
isSetAnnotation()
setAnnotation(const XMLNode* annotation)
setAnnotation(const std::string& annotation)
appendAnnotation(const XMLNode* annotation)
appendAnnotation(const std::string& annotation)
unsetAnnotation()
std::string SBase::getAnnotationString ( )
inherited

Returns the content of the "annotation" subelement of this object as a character string.

Whereas the SBML "notes" subelement is a container for content to be shown directly to humans, the "annotation" element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for "annotation". The element's content type is XML type "any", allowing essentially arbitrary well-formed XML data content.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

The annotations returned by this method will be in string form. See the method getAnnotation() for a version that returns annotations in XML form.

Returns
the annotation of this SBML object as a character string.
See also
getAnnotation()
isSetAnnotation()
setAnnotation(const XMLNode* annotation)
setAnnotation(const std::string& annotation)
appendAnnotation(const XMLNode* annotation)
appendAnnotation(const std::string& annotation)
unsetAnnotation()
Examples:
printAnnotation.cpp.
std::string SBase::getAnnotationString ( ) const
inherited

Returns the content of the "annotation" subelement of this object as a character string.

Whereas the SBML "notes" subelement is a container for content to be shown directly to humans, the "annotation" element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for "annotation". The element's content type is XML type "any", allowing essentially arbitrary well-formed XML data content.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

The annotations returned by this method will be in string form. See the method getAnnotation() for a version that returns annotations in XML form.

Returns
the annotation of this SBML object as a character string.
See also
getAnnotation()
isSetAnnotation()
setAnnotation(const XMLNode* annotation)
setAnnotation(const std::string& annotation)
appendAnnotation(const XMLNode* annotation)
appendAnnotation(const std::string& annotation)
unsetAnnotation()
unsigned int SBase::getColumn ( ) const
inherited

Returns the column number on which this object first appears in the XML representation of the SBML document.

Returns
the column number of this SBML object.
Note
The column number for each construct in an SBML model is set upon reading the model. The accuracy of the column number depends on the correctness of the XML representation of the model, and on the particular XML parser library being used. The former limitation relates to the following problem: if the model is actually invalid XML, then the parser may not be able to interpret the data correctly and consequently may not be able to establish the real column number. The latter limitation is simply that different parsers seem to have their own accuracy limitations, and out of all the parsers supported by libSBML, none have been 100% accurate in all situations. (At this time, libSBML supports the use of libxml2, Expat and Xerces.)
See also
getLine()
const string & Reaction::getCompartment ( ) const

(SBML Level 3 only) Returns the value of the "compartment" attribute on the Reaction.

Returns
the compartment of this Reaction.
Note
The "compartment" attribute is available in SBML Level 3 Version 1 Core, but is not present on Reaction in lower Levels of SBML.
CVTerm * SBase::getCVTerm ( unsigned int  n)
inherited

Returns the nth CVTerm in the list of CVTerms of this SBML object.

Parameters
nunsigned int the index of the CVTerm to retrieve
Returns
the nth CVTerm in the list of CVTerms for this SBML object.
List * SBase::getCVTerms ( )
inherited

Returns a list of CVTerm objects in the annotations of this SBML object.

Returns
the list of CVTerms for this SBML object.
List * SBase::getCVTerms ( ) const
inherited

Returns a list of CVTerm objects in the annotations of this SBML object.

Returns
the list of CVTerms for this SBML object.
SBase * Reaction::getElementByMetaId ( const std::string &  metaid)
virtual

Returns the first child element it can find with the given metaid, or NULL if no such object is found.

Parameters
metaidstring representing the metaid of objects to find
Returns
pointer to the first element found with the given metaid.

Reimplemented from SBase.

SBase * Reaction::getElementBySId ( const std::string &  id)
virtual

Returns the first child element found that has the given id in the model-wide SId namespace, or NULL if no such object is found.

Parameters
idstring representing the id of objects to find.
Returns
pointer to the first element found with the given id.

Reimplemented from SBase.

const string & Reaction::getElementName ( ) const
virtual

Returns the XML element name of this object, which for Reaction, is always "reaction".

Returns
the name of this element, i.e., "reaction".

Implements SBase.

bool Reaction::getFast ( ) const

Returns the value of the "fast" attribute of this Reaction.

Returns
the "fast" status of this Reaction.
Warning
SBML definitions before SBML Level 2 Version 2 incorrectly indicated that software tools could ignore the "fast" attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and "fast" cannot be ignored if it is set to true. Beginning with SBML Level 2 Versions 2, the SBML specifications therefore stipulate that if a model has any reactions with "fast" set to true, a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Readers are directed to the SBML specifications, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense.
const string & Reaction::getId ( ) const
virtual

Returns the value of the "id" attribute of this Reaction.

Returns
the id of this Reaction.
const KineticLaw * Reaction::getKineticLaw ( ) const

Returns the KineticLaw object contained in this Reaction.

Returns
the KineticLaw instance.
Examples:
printAnnotation.cpp, printMath.cpp, printNotes.cpp, printUnits.cpp, unsetAnnotation.cpp, and unsetNotes.cpp.
KineticLaw * Reaction::getKineticLaw ( )

Returns the KineticLaw object contained in this Reaction.

Returns
the KineticLaw instance.
unsigned int SBase::getLevel ( ) const
inherited

Returns the SBML Level of the SBMLDocument object containing this object.

LibSBML uses the class SBMLDocument as a top-level container for storing SBML content and data associated with it (such as warnings and error messages). An SBML model in libSBML is contained inside an SBMLDocument object. SBMLDocument corresponds roughly to the class SBML defined in the SBML Level 3 and Level 2 specifications, but it does not have a direct correspondence in SBML Level 1. (But, it is created by libSBML no matter whether the model is Level 1, Level 2 or Level 3.)
Returns
the SBML level of this SBML object.
See also
getVersion()
getNamespaces()
getPackageVersion()
Examples:
convertSBML.cpp, and printSBML.cpp.
unsigned int SBase::getLine ( ) const
inherited

Returns the line number on which this object first appears in the XML representation of the SBML document.

Returns
the line number of this SBML object.
Note
The line number for each construct in an SBML model is set upon reading the model. The accuracy of the line number depends on the correctness of the XML representation of the model, and on the particular XML parser library being used. The former limitation relates to the following problem: if the model is actually invalid XML, then the parser may not be able to interpret the data correctly and consequently may not be able to establish the real line number. The latter limitation is simply that different parsers seem to have their own accuracy limitations, and out of all the parsers supported by libSBML, none have been 100% accurate in all situations. (At this time, libSBML supports the use of libxml2, Expat and Xerces.)
See also
getColumn()
const ListOfSpeciesReferences * Reaction::getListOfModifiers ( ) const

Returns the list of modifiers in this Reaction object.

Returns
the ListOfSpeciesReferences containing the references to the species acting as modifiers in this reaction
ListOfSpeciesReferences * Reaction::getListOfModifiers ( )

Returns the list of modifiers in this Reaction object.

Returns
the ListOfSpeciesReferences containing the references to the species acting as modifiers in this reaction
const ListOfSpeciesReferences * Reaction::getListOfProducts ( ) const

Returns the list of products in this Reaction object.

Returns
the ListOfSpeciesReferences containing the references to the species acting as products in this reaction
ListOfSpeciesReferences * Reaction::getListOfProducts ( )

Returns the list of products in this Reaction object.

Returns
the ListOfSpeciesReferences containing the references to the species acting as products in this reaction
const ListOfSpeciesReferences * Reaction::getListOfReactants ( ) const

Returns the list of reactants in this Reaction object.

Returns
the ListOfSpeciesReferences containing the references to the species acting as reactants in this reaction
ListOfSpeciesReferences * Reaction::getListOfReactants ( )

Returns the list of reactants in this Reaction object.

Returns
the ListOfSpeciesReferences containing the references to the species acting as reactants in this reaction
const string & SBase::getMetaId ( ) const
inherited

Returns the value of the "metaid" attribute of this object.

The optional attribute named "metaid", present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each "metaid" value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the "metaid" attribute used by SBML—something to be aware of if your application-specific XML content inside the "annotation" subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the "metaid" attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the "annotation" subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support.
Returns
the meta-identifier of this SBML object.
See also
isSetMetaId()
setMetaId(const std::string& metaid)
Examples:
addingEvidenceCodes_2.cpp.
string & SBase::getMetaId ( )
inherited

Returns the value of the "metaid" attribute of this object.

The optional attribute named "metaid", present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each "metaid" value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the "metaid" attribute used by SBML—something to be aware of if your application-specific XML content inside the "annotation" subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the "metaid" attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the "annotation" subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support.
Returns
the meta-identifier of this SBML object, as a string.
See also
isSetMetaId()
setMetaId(const std::string& metaid)
const Model * SBase::getModel ( ) const
inherited

Returns the Model object for the SBML Document in which the current object is located.

Returns
the Model object for the SBML Document of this SBML object.
See also
getParentSBMLObject()
getSBMLDocument()
ModelHistory * SBase::getModelHistory ( ) const
inherited

Returns the ModelHistory object, if any, attached to this object.

Returns
the ModelHistory object attached to this object, or NULL if none exist.
Note
In SBML Level 2, model history annotations were only permitted on the Model element. In SBML Level 3, they are permitted on all SBML components derived from SBase.
ModelHistory * SBase::getModelHistory ( )
inherited

Returns the ModelHistory object, if any, attached to this object.

Returns
the ModelHistory object attached to this object, or NULL if none exist.
Note
In SBML Level 2, model history annotations were only permitted on the Model element. In SBML Level 3, they are permitted on all SBML components derived from SBase.
const ModifierSpeciesReference * Reaction::getModifier ( unsigned int  n) const

Returns the nth modifier species (as a ModifierSpeciesReference object) in the list of modifiers of this Reaction.

Callers should first call getNumModifiers() to find out how many modifiers there are, to avoid using an invalid index number.

Parameters
nthe index of the modifier species sought
Returns
the nth modifier (as a ModifierSpeciesReference object) of this Reaction.
Examples:
printAnnotation.cpp, printNotes.cpp, unsetAnnotation.cpp, and unsetNotes.cpp.
ModifierSpeciesReference * Reaction::getModifier ( unsigned int  n)

Returns the nth modifier species (as a ModifierSpeciesReference object) in the list of modifiers of this Reaction.

Callers should first call getNumModifiers() to find out how many modifiers there are, to avoid using an invalid index number.

Parameters
nthe index of the modifier species sought
Returns
the nth modifier (as a ModifierSpeciesReference object) of this Reaction.
const ModifierSpeciesReference * Reaction::getModifier ( const std::string &  species) const

Returns the modifier species (as a ModifierSpeciesReference object) having a specific identifier in this Reaction.

Parameters
speciesthe identifier of the modifier Species ("species" attribute of the ModifierSpeciesReference object)
Returns
a ModifierSpeciesReference object, or NULL if no species with the given identifier species appears as a modifier in this Reaction.
ModifierSpeciesReference * Reaction::getModifier ( const std::string &  species)

Returns the modifier species (as a ModifierSpeciesReference object) having a specific identifier in this Reaction.

Parameters
speciesthe identifier of the modifier Species ("species" attribute of the ModifierSpeciesReference object)
Returns
a ModifierSpeciesReference object, or NULL if no species with the given identifier species appears as a modifier in this Reaction.
const string & Reaction::getName ( ) const
virtual

Returns the value of the "name" attribute of this Reaction.

Returns
the name of this Reaction.
XMLNamespaces * SBase::getNamespaces ( ) const
virtualinherited

Returns a list of the XML Namespaces declared on this SBML document.

The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core.

Returns
the XML Namespaces associated with this SBML object, or NULL in certain very usual circumstances where a namespace is not set.
See also
getLevel()
getVersion()

Reimplemented in SBMLDocument.

XMLNode * SBase::getNotes ( )
inherited

Returns the content of the "notes" subelement of this object as a tree of XMLNode objects.

The optional SBML element named "notes", present on every major SBML component type (and in SBML Level 3, the "message" subelement of Constraint), is intended as a place for storing optional information intended to be seen by humans. An example use of the "notes" element would be to contain formatted user comments about the model element in which the "notes" element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for "notes", allowing users considerable freedom when adding comments to their models.

The format of "notes" elements conform to the definition of XHTML 1.0. However, the content cannot be entirely free-form; it must satisfy certain requirements defined in the SBML specifications for specific SBML Levels. To help verify the formatting of "notes" content, libSBML provides the static utility method SyntaxChecker::hasExpectedXHTMLSyntax(); The method implements a verification process that lets callers check whether the content of a given XMLNode object conforms to the SBML requirements for "notes" and "message" structure. Developers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations of using "notes" in SBML. The SBML Level 2 and  3 specifications have considerable detail about how "notes" element content must be structured.

The "notes" element content returned by this method will be in XML form, but libSBML does not provide an object model specifically for the content of notes. Callers will need to traverse the XML tree structure using the facilities available on XMLNode and related objects. For an alternative method of accessing the notes, see getNotesString().

Returns
the content of the "notes" subelement of this SBML object as a tree structure composed of XMLNode objects.
See also
getNotesString()
isSetNotes()
setNotes(const XMLNode* notes)
setNotes(const std::string& notes, bool addXHTMLMarkup)
appendNotes(const XMLNode* notes)
appendNotes(const std::string& notes)
unsetNotes()
SyntaxChecker::hasExpectedXHTMLSyntax()
XMLNode * SBase::getNotes ( ) const
inherited

Returns the content of the "notes" subelement of this object as a tree of XMLNode objects.

The optional SBML element named "notes", present on every major SBML component type (and in SBML Level 3, the "message" subelement of Constraint), is intended as a place for storing optional information intended to be seen by humans. An example use of the "notes" element would be to contain formatted user comments about the model element in which the "notes" element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for "notes", allowing users considerable freedom when adding comments to their models.

The format of "notes" elements conform to the definition of XHTML 1.0. However, the content cannot be entirely free-form; it must satisfy certain requirements defined in the SBML specifications for specific SBML Levels. To help verify the formatting of "notes" content, libSBML provides the static utility method SyntaxChecker::hasExpectedXHTMLSyntax(); The method implements a verification process that lets callers check whether the content of a given XMLNode object conforms to the SBML requirements for "notes" and "message" structure. Developers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations of using "notes" in SBML. The SBML Level 2 and  3 specifications have considerable detail about how "notes" element content must be structured.

The "notes" element content returned by this method will be in XML form, but libSBML does not provide an object model specifically for the content of notes. Callers will need to traverse the XML tree structure using the facilities available on XMLNode and related objects. For an alternative method of accessing the notes, see getNotesString().

Returns
the content of the "notes" subelement of this SBML object as a tree structure composed of XMLNode objects.
See also
getNotesString()
isSetNotes()
setNotes(const XMLNode* notes)
setNotes(const std::string& notes, bool addXHTMLMarkup)
appendNotes(const XMLNode* notes)
appendNotes(const std::string& notes)
unsetNotes()
SyntaxChecker::hasExpectedXHTMLSyntax()
std::string SBase::getNotesString ( )
inherited

Returns the content of the "notes" subelement of this object as a string.

The optional SBML element named "notes", present on every major SBML component type (and in SBML Level 3, the "message" subelement of Constraint), is intended as a place for storing optional information intended to be seen by humans. An example use of the "notes" element would be to contain formatted user comments about the model element in which the "notes" element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for "notes", allowing users considerable freedom when adding comments to their models.

The format of "notes" elements conform to the definition of XHTML 1.0. However, the content cannot be entirely free-form; it must satisfy certain requirements defined in the SBML specifications for specific SBML Levels. To help verify the formatting of "notes" content, libSBML provides the static utility method SyntaxChecker::hasExpectedXHTMLSyntax(); The method implements a verification process that lets callers check whether the content of a given XMLNode object conforms to the SBML requirements for "notes" and "message" structure. Developers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations of using "notes" in SBML. The SBML Level 2 and  3 specifications have considerable detail about how "notes" element content must be structured.

For an alternative method of accessing the notes, see getNotes(), which returns the content as an XMLNode tree structure. Depending on an application's needs, one or the other method may be more convenient.

Returns
the content of the "notes" subelement of this SBML object as a string.
See also
getNotes()
isSetNotes()
setNotes(const XMLNode* notes)
setNotes(const std::string& notes, bool addXHTMLMarkup)
appendNotes(const XMLNode* notes)
appendNotes(const std::string& notes)
unsetNotes()
SyntaxChecker::hasExpectedXHTMLSyntax()
Examples:
printNotes.cpp.
std::string SBase::getNotesString ( ) const
inherited

Returns the content of the "notes" subelement of this object as a string.

The optional SBML element named "notes", present on every major SBML component type (and in SBML Level 3, the "message" subelement of Constraint), is intended as a place for storing optional information intended to be seen by humans. An example use of the "notes" element would be to contain formatted user comments about the model element in which the "notes" element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for "notes", allowing users considerable freedom when adding comments to their models.

The format of "notes" elements conform to the definition of XHTML 1.0. However, the content cannot be entirely free-form; it must satisfy certain requirements defined in the SBML specifications for specific SBML Levels. To help verify the formatting of "notes" content, libSBML provides the static utility method SyntaxChecker::hasExpectedXHTMLSyntax(); The method implements a verification process that lets callers check whether the content of a given XMLNode object conforms to the SBML requirements for "notes" and "message" structure. Developers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations of using "notes" in SBML. The SBML Level 2 and  3 specifications have considerable detail about how "notes" element content must be structured.

For an alternative method of accessing the notes, see getNotes(), which returns the content as an XMLNode tree structure. Depending on an application's needs, one or the other method may be more convenient.

Returns
the content of the "notes" subelement of this SBML object as a string.
See also
getNotes()
isSetNotes()
setNotes(const XMLNode* notes)
setNotes(const std::string& notes, bool addXHTMLMarkup)
appendNotes(const XMLNode* notes)
appendNotes(const std::string& notes)
unsetNotes()
SyntaxChecker::hasExpectedXHTMLSyntax()
unsigned int SBase::getNumCVTerms ( )
inherited

Returns the number of CVTerm objects in the annotations of this SBML object.

Returns
the number of CVTerms for this SBML object.
unsigned int Reaction::getNumModifiers ( ) const

Returns the number of modifier species in this Reaction.

Returns
the number of modifiers in this Reaction.
Examples:
printAnnotation.cpp, printNotes.cpp, unsetAnnotation.cpp, and unsetNotes.cpp.
unsigned int SBase::getNumPlugins ( ) const
inherited

Returns the number of plug-in objects (extenstion interfaces) for SBML Level 3 package extensions known.

SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages.
Returns
the number of plug-in objects (extension interfaces) of package extensions known by this instance of libSBML.
unsigned int Reaction::getNumProducts ( ) const

Returns the number of product species in this Reaction.

Returns
the number of products in this Reaction.
Examples:
printAnnotation.cpp, printNotes.cpp, printUnits.cpp, unsetAnnotation.cpp, and unsetNotes.cpp.
unsigned int Reaction::getNumReactants ( ) const

Returns the number of reactant species in this Reaction.

Returns
the number of reactants in this Reaction.
Examples:
printAnnotation.cpp, printNotes.cpp, printUnits.cpp, unsetAnnotation.cpp, and unsetNotes.cpp.
const std::string & SBase::getPackageName ( ) const
inherited

Returns the name of the SBML Level 3 package in which this element is defined.

Returns
the name of the SBML package in which this element is defined. The string "core" will be returned if this element is defined in SBML Level 3 Core. The string "unknown" will be returned if this element is not defined in any SBML package.
unsigned int SBase::getPackageVersion ( ) const
inherited

Returns the Version of the SBML Level 3 package to which this element belongs to.

Returns
the version of the SBML Level 3 package to which this element belongs. The value 0 will be returned if this element belongs to the SBML Level 3 Core package.
See also
getLevel()
getVersion()
SBase * SBase::getParentSBMLObject ( )
inherited

Returns the parent SBML object containing this object.

This returns the immediately-containing object. This method is convenient when holding an object nested inside other objects in an SBML model.

Returns
the parent SBML object of this SBML object.
See also
getSBMLDocument()
getModel()
const SBase * SBase::getParentSBMLObject ( ) const
inherited

Returns the parent SBML object containing this object.

This returns the immediately-containing object. This method is convenient when holding an object nested inside other objects in an SBML model.

Returns
the parent SBML object of this SBML object.
See also
getSBMLDocument()
getModel()
SBasePlugin * SBase::getPlugin ( const std::string &  package)
inherited

Returns a plug-in object (extension interface) for an SBML Level 3 package extension with the given package name or URI.

SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages.
Parameters
packagethe name or URI of the package
Returns
the plug-in object (the libSBML extension interface) of a package extension with the given package name or URI.
const SBasePlugin * SBase::getPlugin ( const std::string &  package) const
inherited

Returns a plug-in object (extension interface) for an SBML Level 3 package extension with the given package name or URI.

SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages.
Parameters
packagethe name or URI of the package
Returns
the plug-in object (the libSBML extension interface) of a package extension with the given package name or URI.
SBasePlugin * SBase::getPlugin ( unsigned int  n)
inherited

Returns the nth plug-in object (extension interface) for an SBML Level 3 package extension.

SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages.
Parameters
nthe index of the plug-in to return
Returns
the plug-in object (the libSBML extension interface) of a package extension with the given package name or URI.
const SBasePlugin * SBase::getPlugin ( unsigned int  n) const
inherited

Returns the nth plug-in object (extension interface) for an SBML Level 3 package extension.

SBML Level 3 consists of a Core definition that can be extended via optional SBML Level 3 packages. A given model may indicate that it uses one or more SBML packages, and likewise, a software tool may be able to support one or more packages. LibSBML does not come preconfigured with all possible packages included and enabled, in part because not all package specifications have been finalized. To support the ability for software systems to enable support for the Level 3 packages they choose, libSBML features a plug-in mechanism. Each SBML Level 3 package is implemented in a separate code plug-in that can be enabled by the application to support working with that SBML package. A given SBML model may thus contain not only objects defined by SBML Level 3 Core, but also objects created by libSBML plug-ins supporting additional Level 3 packages.
Parameters
nthe index of the plug-in to return
Returns
the plug-in object (the libSBML extension interface) of a package extension with the given package name or URI.
std::string SBase::getPrefix ( ) const
inherited

Returns the namespace prefix of this element.

const SpeciesReference * Reaction::getProduct ( unsigned int  n) const

Returns the nth product species (as a SpeciesReference object) in the list of products in this Reaction.

Callers should first call getNumProducts() to find out how many products there are, to avoid using an invalid index number.

Parameters
nthe index of the product sought.
Returns
the nth product (as a SpeciesReference object) of this Reaction.
Examples:
printAnnotation.cpp, printNotes.cpp, printUnits.cpp, unsetAnnotation.cpp, and unsetNotes.cpp.
SpeciesReference * Reaction::getProduct ( unsigned int  n)

Returns the nth product species (as a SpeciesReference object) in the list of products in this Reaction.

Callers should first call getNumProducts() to find out how many products there are, to avoid using an invalid index number.

Parameters
nthe index of the product sought.
Returns
the nth product (as a SpeciesReference object) of this Reaction.
const SpeciesReference * Reaction::getProduct ( const std::string &  species) const

Returns the product species (as a SpeciesReference object) having a specific identifier in this Reaction.

Parameters
speciesthe identifier of the product Species ("species" attribute of the product SpeciesReference object)
Returns
a SpeciesReference object, or NULL if no species with the given identifier species appears as a product in this Reaction.
SpeciesReference * Reaction::getProduct ( const std::string &  species)

Returns the product species (as a SpeciesReference object) having a specific identifier in this Reaction.

Parameters
speciesthe identifier of the product Species ("species" attribute of the product SpeciesReference object)
Returns
a SpeciesReference object, or NULL if no species with the given identifier species appears as a product in this Reaction.
const SpeciesReference * Reaction::getReactant ( unsigned int  n) const

Returns the nth reactant species (as a SpeciesReference object) in the list of reactants in this Reaction.

Callers should first call getNumReactants() to find out how many reactants there are, to avoid using an invalid index number.

Parameters
nthe index of the reactant sought.
Returns
the nth reactant (as a SpeciesReference object) of this Reaction.
Examples:
printAnnotation.cpp, printNotes.cpp, printUnits.cpp, unsetAnnotation.cpp, and unsetNotes.cpp.
SpeciesReference * Reaction::getReactant ( unsigned int  n)

Returns the nth reactant species (as a SpeciesReference object) in the list of reactants in this Reaction.

Callers should first call getNumReactants() to find out how many reactants there are, to avoid using an invalid index number.

Parameters
nthe index of the reactant sought.
Returns
the nth reactant (as a SpeciesReference object) of this Reaction.
const SpeciesReference * Reaction::getReactant ( const std::string &  species) const

Returns the reactant species (as a SpeciesReference object) having a specific identifier in this Reaction.

Parameters
speciesthe identifier of the reactant Species ("species" attribute of the reactant SpeciesReference object)
Returns
a SpeciesReference object, or NULL if no species with the given identifier species appears as a reactant in this Reaction.
SpeciesReference * Reaction::getReactant ( const std::string &  species)

Returns the reactant species (as a SpeciesReference object) having a specific identifier in this Reaction.

Parameters
speciesthe identifier of the reactant Species ("species" attribute of the reactant SpeciesReference object)
Returns
a SpeciesReference object, or NULL if no species with the given identifier species appears as a reactant in this Reaction.
BiolQualifierType_t SBase::getResourceBiologicalQualifier ( std::string  resource)
inherited

Returns the MIRIAM biological qualifier associated with the given resource.

In MIRIAM, qualifiers are an optional means of indicating the relationship between a model component and its annotations. There are two broad kinds of annotations: model and biological. The latter kind is used to qualify the relationship between a model component and a biological entity which it represents. Examples of relationships include "is" and "has part", but many others are possible. MIRIAM defines numerous relationship qualifiers to enable different software tools to qualify biological annotations in the same standardized way. In libSBML, the MIRIAM controlled-vocabulary annotations on an SBML model element are represented using lists of CVTerm objects, and the the MIRIAM biological qualifiers are represented using values

This method searches the controlled-vocabulary annotations (i.e., the list of CVTerm objects) on the present object, then out of those that have biological qualifiers, looks for an annotation to the given resource. If such an annotation is found, it returns the type of biological qualifier associated with that resource as a value

Parameters
resourcestring representing the resource; e.g., "http://www.geneontology.org/#GO:0005892".
Returns
the qualifier associated with the resource, or BQB_UNKNOWN if the resource does not exist.
ModelQualifierType_t SBase::getResourceModelQualifier ( std::string  resource)
inherited

Returns the MIRIAM model qualifier associated with the given resource.

In MIRIAM, qualifiers are an optional means of indicating the relationship between a model component and its annotations. There are two broad kinds of annotations: model and biological. The former kind is used to qualify the relationship between a model component and another modeling object. An example qualifier is "isDerivedFrom", to indicate that a given component of the model is derived from the modeling object represented by the referenced resource. MIRIAM defines numerous relationship qualifiers to enable different software tools to qualify model annotations in the same standardized way. In libSBML, the MIRIAM controlled-vocabulary annotations on an SBML model element are represented using lists of CVTerm objects, and the the MIRIAM model qualifiers are represented using values

This method method searches the controlled-vocabulary annotations (i.e., the list of CVTerm objects) on the present object, then out of those that have model qualifiers, looks for an annotation to the given resource. If such an annotation is found, it returns the type of type of model qualifier associated with that resource as a value

Parameters
resourcestring representing the resource; e.g., "http://www.geneontology.org/#GO:0005892".
Returns
the model qualifier type associated with the resource, or BQM_UNKNOWN if the resource does not exist.
bool Reaction::getReversible ( ) const

Returns the value of the "reversible" attribute on the Reaction as a boolean value.

Returns
the reversibility status of this Reaction.
const SBMLDocument * SBase::getSBMLDocument ( ) const
inherited

Returns the SBMLDocument object containing this object instance.

LibSBML uses the class SBMLDocument as a top-level container for storing SBML content and data associated with it (such as warnings and error messages). An SBML model in libSBML is contained inside an SBMLDocument object. SBMLDocument corresponds roughly to the class SBML defined in the SBML Level 3 and Level 2 specifications, but it does not have a direct correspondence in SBML Level 1. (But, it is created by libSBML no matter whether the model is Level 1, Level 2 or Level 3.)

This method allows the caller to obtain the SBMLDocument for the current object.

Returns
the parent SBMLDocument object of this SBML object.
See also
getParentSBMLObject()
getModel()
SBMLDocument * SBase::getSBMLDocument ( )
inherited

Returns the SBMLDocument object containing this object instance.

LibSBML uses the class SBMLDocument as a top-level container for storing SBML content and data associated with it (such as warnings and error messages). An SBML model in libSBML is contained inside an SBMLDocument object. SBMLDocument corresponds roughly to the class SBML defined in the SBML Level 3 and Level 2 specifications, but it does not have a direct correspondence in SBML Level 1. (But, it is created by libSBML no matter whether the model is Level 1, Level 2 or Level 3.)

This method allows the caller to obtain the SBMLDocument for the current object.

Returns
the parent SBMLDocument object of this SBML object.
See also
getParentSBMLObject()
getModel()
int SBase::getSBOTerm ( ) const
inherited

Returns the integer portion of the value of the "sboTerm" attribute of this object.

Beginning with SBML Level 2 Version 3, objects derived from SBase have an optional attribute named "sboTerm" for supporting the use of the Systems Biology Ontology. In SBML proper, the data type of the attribute is a string of the form "SBO:NNNNNNN", where "NNNNNNN" is a seven digit integer number; libSBML simplifies the representation by only storing the "NNNNNNN" integer portion. Thus, in libSBML, the "sboTerm" attribute on SBase has data type int, and SBO identifiers are stored simply as integers. (For convenience, libSBML offers methods for returning both the integer form and a text-string form of the SBO identifier.)

SBO terms are a type of optional annotation, and each different class of SBML object derived from SBase imposes its own requirements about the values permitted for "sboTerm". Please consult the SBML Level 2 Version 4 specification for more information about the use of SBO and the "sboTerm" attribute.

Returns
the value of the "sboTerm" attribute as an integer, or -1 if the value is not set.
Examples:
printSBML.cpp.
std::string SBase::getSBOTermAsURL ( ) const
inherited

Returns the identifiers.org URL representation of the "sboTerm" attribute of this object.

This method returns the entire SBO identifier as a text string in the form "http://identifiers.org/biomodels.sbo/SBO:NNNNNNN".

SBO terms are a type of optional annotation, and each different class of SBML object derived from SBase imposes its own requirements about the values permitted for "sboTerm". Please consult the SBML Level 2 Version 4 specification for more information about the use of SBO and the "sboTerm" attribute.

Returns
the value of the "sboTerm" attribute as an identifiers.org URL (its value will be of the form "http://identifiers.org/biomodels.sbo/SBO:NNNNNNN"), or an empty string if the value is not set.
std::string SBase::getSBOTermID ( ) const
inherited

Returns the string representation of the "sboTerm" attribute of this object.

Beginning with SBML Level 2 Version 3, objects derived from SBase have an optional attribute named "sboTerm" for supporting the use of the Systems Biology Ontology. In SBML proper, the data type of the attribute is a string of the form "SBO:NNNNNNN", where "NNNNNNN" is a seven digit integer number; libSBML simplifies the representation by only storing the "NNNNNNN" integer portion. Thus, in libSBML, the "sboTerm" attribute on SBase has data type int, and SBO identifiers are stored simply as integers. This method returns the entire SBO identifier as a text string in the form "SBO:NNNNNNN".

SBO terms are a type of optional annotation, and each different class of SBML object derived from SBase imposes its own requirements about the values permitted for "sboTerm". Please consult the SBML Level 2 Version 4 specification for more information about the use of SBO and the "sboTerm" attribute.

Returns
the value of the "sboTerm" attribute as a string (its value will be of the form "SBO:NNNNNNN"), or an empty string if the value is not set.
int Reaction::getTypeCode ( ) const
virtual

Returns the libSBML type code for this SBML object.

LibSBML attaches an identifying code to every kind of SBML object. These are integer constants known as SBML type codes. The names of all the codes begin with the characters “SBML_”. Note that different Level 3 package plug-ins may use overlapping type codes; to identify the package to which a given object belongs, call the getPackageName() method on the object.
Returns
the SBML type code for this object: SBML_REACTION (default).
Warning
The specific integer values of the possible type codes may be reused by different Level 3 package plug-ins. Thus, to identifiy the correct code, it is necessary to invoke both getTypeCode() and getPackageName().
See also
getElementName()
getPackageName()

Reimplemented from SBase.

std::string SBase::getURI ( ) const
inherited

Gets the namespace URI to which this element belongs to.

For example, all elements that belong to SBML Level 3 Version 1 Core must would have the URI "http://www.sbml.org/sbml/level3/version1/core"; all elements that belong to Layout Extension Version 1 for SBML Level 3 Version 1 Core must would have the URI "http://www.sbml.org/sbml/level3/version1/layout/version1/"

This function first returns the URI for this element by looking into the SBMLNamespaces object of the document with the its package name. If not found, it willreturn the XML namespace to which this element belongs.

Returns
the URI of this element
See also
getSBMLDocument()
getPackageName()
void * SBase::getUserData ( ) const
inherited

Returns the user data that has been previously set via setUserData().

The user data associated with an SBML object can be used by an application developer to attach custom information to that object in the model. In case of a deep copy, this attribute will passed as it is. The attribute will be never interpreted by libSBML.
Returns
the user data of this node, or NULL if no user data has been set.
unsigned int SBase::getVersion ( ) const
inherited

Returns the Version within the SBML Level of the SBMLDocument object containing this object.

LibSBML uses the class SBMLDocument as a top-level container for storing SBML content and data associated with it (such as warnings and error messages). An SBML model in libSBML is contained inside an SBMLDocument object. SBMLDocument corresponds roughly to the class SBML defined in the SBML Level 3 and Level 2 specifications, but it does not have a direct correspondence in SBML Level 1. (But, it is created by libSBML no matter whether the model is Level 1, Level 2 or Level 3.)
Returns
the SBML version of this SBML object.
See also
getLevel()
getNamespaces()
Examples:
convertSBML.cpp, and printSBML.cpp.
bool Reaction::hasRequiredAttributes ( ) const
virtual

Predicate returning true if all the required attributes for this Reaction object have been set.

Note
The required attributes for a Reaction object are:
  • "id" (or "name" in SBML Level 1)
  • "fast" (in Level 3 only, where it is defined as a required attribute)
  • "reversible" (in Level 3 only, where it is defined as a required attribute)
Returns
a boolean value indicating whether all the required attributes for this object have been defined.
bool SBase::hasValidLevelVersionNamespaceCombination ( )
inherited

Predicate returning true if this object's level/version and namespace values correspond to a valid SBML specification.

The valid combinations of SBML Level, Version and Namespace as of this release of libSBML are the following:

  • Level 1 Version 2: "http://www.sbml.org/sbml/level1"
  • Level 2 Version 1: "http://www.sbml.org/sbml/level2"
  • Level 2 Version 2: "http://www.sbml.org/sbml/level2/version2"
  • Level 2 Version 3: "http://www.sbml.org/sbml/level2/version3"
  • Level 2 Version 4: "http://www.sbml.org/sbml/level2/version4"
  • Level 3 Version 1 Core: "http://www.sbml.org/sbml/level3/version1/core"
Returns
true if the level, version and namespace values of this SBML object correspond to a valid set of values, false otherwise.
void Reaction::initDefaults ( )

Initializes the fields of this Reaction object to "typical" default values.

The SBML Reaction component has slightly different aspects and default attribute values in different SBML Levels and Versions. This method sets the values to certain common defaults, based mostly on what they are in SBML Level 2. Specifically:

  • Sets the "reversible" attribute to true
  • Sets the "fast" attribute to false
  • Marks the "fast" attribute as not having been set
Warning
SBML definitions before SBML Level 2 Version 2 incorrectly indicated that software tools could ignore the "fast" attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and "fast" cannot be ignored if it is set to true. Beginning with SBML Level 2 Versions 2, the SBML specifications therefore stipulate that if a model has any reactions with "fast" set to true, a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Readers are directed to the SBML specifications, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense.
bool SBase::isPackageEnabled ( const std::string &  pkgName) const
inherited

Predicate returning true if the given SBML Level 3 package is enabled with this object.

The search ignores the package version.

Parameters
pkgNamethe name of the package
Returns
true if the given package is enabled within this object, false otherwise.
See also
isPackageURIEnabled()
bool SBase::isPackageURIEnabled ( const std::string &  pkgURI) const
inherited

Predicate returning true if an SBML Level 3 package with the given URI is enabled with this object.

Parameters
pkgURIthe URI of the package
Returns
true if the given package is enabled within this object, false otherwise.
See also
isPackageEnabled()
bool SBase::isPkgEnabled ( const std::string &  pkgName) const
inherited

Predicate returning true if the given SBML Level 3 package is enabled with this object.

The search ignores the package version.

Parameters
pkgNamethe name of the package
Returns
true if the given package is enabled within this object, false otherwise.
See also
isPkgURIEnabled()
bool SBase::isPkgURIEnabled ( const std::string &  pkgURI) const
inherited

Predicate returning true if an SBML Level 3 package with the given URI is enabled with this object.

Parameters
pkgURIthe URI of the package
Returns
true if the given package is enabled within this object, false otherwise.
See also
isPkgEnabled()
bool SBase::isSetAnnotation ( ) const
inherited

Predicate returning true if this object's "annotation" subelement exists and has content.

Whereas the SBase "notes" subelement is a container for content to be shown directly to humans, the "annotation" element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for "annotation". The element's content type is XML type "any", allowing essentially arbitrary well-formed XML data content.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

Returns
true if a "annotation" subelement exists, false otherwise.
See also
getAnnotation()
getAnnotationString()
setAnnotation(const XMLNode* annotation)
setAnnotation(const std::string& annotation)
appendAnnotation(const XMLNode* annotation)
appendAnnotation(const std::string& annotation)
unsetAnnotation()
Examples:
printAnnotation.cpp.
bool Reaction::isSetCompartment ( ) const

Predicate returning true if this Reaction's "compartment" attribute is set.

Returns
true if the "compartment" attribute of this Reaction is set, false otherwise.
Note
The "compartment" attribute is available in SBML Level 3 Version 1 Core, but is not present on Reaction in lower Levels of SBML.
bool Reaction::isSetFast ( ) const

Predicate returning true if the value of the "fast" attribute on this Reaction.

Returns
true if the "fast" attribute is true, false otherwise.
Warning
SBML definitions before SBML Level 2 Version 2 incorrectly indicated that software tools could ignore the "fast" attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and "fast" cannot be ignored if it is set to true. Beginning with SBML Level 2 Versions 2, the SBML specifications therefore stipulate that if a model has any reactions with "fast" set to true, a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Readers are directed to the SBML specifications, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense.
bool Reaction::isSetId ( ) const
virtual

Predicate returning true if this Reaction's "id" attribute is set.

Returns
true if the "id" attribute of this Reaction is set, false otherwise.
bool Reaction::isSetKineticLaw ( ) const

Predicate returning true if this Reaction contains a kinetic law object.

Returns
true if a KineticLaw is present in this Reaction,, false otherwise.
Examples:
printAnnotation.cpp, printMath.cpp, printNotes.cpp, printUnits.cpp, unsetAnnotation.cpp, and unsetNotes.cpp.
bool SBase::isSetMetaId ( ) const
inherited

Predicate returning true if this object's "metaid" attribute is set.

The optional attribute named "metaid", present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each "metaid" value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the "metaid" attribute used by SBML—something to be aware of if your application-specific XML content inside the "annotation" subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the "metaid" attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the "annotation" subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support.
Returns
true if the "metaid" attribute of this SBML object is set, false otherwise.
See also
getMetaId()
setMetaId(const std::string& metaid)
Examples:
addingEvidenceCodes_1.cpp, and addingEvidenceCodes_2.cpp.
bool SBase::isSetModelHistory ( )
inherited

Predicate returning true if this object has a ModelHistory object attached to it.

Returns
true if the ModelHistory of this object is set, false otherwise.
Note
In SBML Level 2, model history annotations were only permitted on the Model element. In SBML Level 3, they are permitted on all SBML components derived from SBase.
bool Reaction::isSetName ( ) const
virtual

Predicate returning true if this Reaction's "name" attribute is set.

Returns
true if the "name" attribute of this Reaction is set, false otherwise.
bool SBase::isSetNotes ( ) const
inherited

Predicate returning true if this object's "notes" subelement exists and has content.

The optional SBML element named "notes", present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the "notes" element would be to contain formatted user comments about the model element in which the "notes" element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for "notes", allowing users considerable freedom when adding comments to their models.

The format of "notes" elements must be XHTML 1.0. To help verify the formatting of "notes" content, libSBML provides the static utility method SyntaxChecker::hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and  3 specifications have considerable detail about how "notes" element content must be structured.

Returns
true if a "notes" subelement exists, false otherwise.
See also
getNotes()
getNotesString()
setNotes(const XMLNode* notes)
setNotes(const std::string& notes, bool addXHTMLMarkup)
appendNotes(const XMLNode* notes)
appendNotes(const std::string& notes)
unsetNotes()
SyntaxChecker::hasExpectedXHTMLSyntax()
Examples:
getAllElementsWithNotes.cpp, and printNotes.cpp.
bool Reaction::isSetReversible ( ) const

Predicate returning true if this Reaction's "reversible" attribute is set.

Returns
true if the "reversible" attribute of this Reaction is set, false otherwise.
bool SBase::isSetSBOTerm ( ) const
inherited

Predicate returning true if this object's "sboTerm" attribute is set.

Returns
true if the "sboTerm" attribute of this SBML object is set, false otherwise.
Examples:
printSBML.cpp.
bool SBase::matchesRequiredSBMLNamespacesForAddition ( const SBase sb)
inherited

Returns true if this object's set of XML namespaces are a subset of the given object's XML namespaces.

The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments.
Parameters
sban object to compare with respect to namespaces
Returns
boolean, true if this object's collection of namespaces is a subset of sb's, false otherwise.
bool SBase::matchesRequiredSBMLNamespacesForAddition ( const SBase sb) const
inherited

Returns true if this object's set of XML namespaces are a subset of the given object's XML namespaces.

The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments.
Parameters
sban object to compare with respect to namespaces
Returns
boolean, true if this object's collection of namespaces is a subset of sb's, false otherwise.
bool SBase::matchesSBMLNamespaces ( const SBase sb)
inherited

Returns true if this object's set of XML namespaces are the same as the given object's XML namespaces.

The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments.
Parameters
sban object to compare with respect to namespaces
Returns
boolean, true if this object's collection of namespaces is the same as sb's, false otherwise.
bool SBase::matchesSBMLNamespaces ( const SBase sb) const
inherited

Returns true if this object's set of XML namespaces are the same as the given object's XML namespaces.

The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core. A common approach to using libSBML's SBMLNamespaces facilities is to create an SBMLNamespaces object somewhere in a program once, then hand that object as needed to object constructors that accept SBMLNamespaces as arguments.
Parameters
sban object to compare with respect to namespaces
Returns
boolean, true if this object's collection of namespaces is the same as sb's, false otherwise.
Reaction & Reaction::operator= ( const Reaction rhs)

Assignment operator for Reaction.

Parameters
rhsThe object whose values are used as the basis of the assignment.
Exceptions
SBMLConstructorExceptionThrown if the argument rhs is NULL.
void SBase::read ( XMLNode node,
XMLErrorSeverityOverride_t  flag = LIBSBML_OVERRIDE_DISABLED 
)
inherited

Reads (initializes) this SBML object by reading from the given XMLNode.

Parameters
nodeThe XMLNode to read from.
flagAn optional flag that determines how how errors are logged during the reading process.
Warning
This method is computationally expensive, because the given node has to be serialized to a string first. Attempting to serialize a large tree structure (e.g., a large Model) may consume significant computer memory and time.
int SBase::removeFromParentAndDelete ( )
virtualinherited

Removes this object from its parent.

If the parent was storing this object as a pointer, it is deleted. If not, it is simply cleared (as in ListOf objects). This is a pure virtual method, as every SBase element has different parents, and therefore different methods of removing itself. Will fail (and not delete itself) if it has no parent object. This function is designed to be overridden, but for all objects whose parent is of the class ListOf, the default implementation will work.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:

Reimplemented in Model, KineticLaw, SBaseRef, StoichiometryMath, Trigger, Delay, Priority, ListOf, ModelDefinition, and ReplacedBy.

ModifierSpeciesReference * Reaction::removeModifier ( unsigned int  n)

Removes the nth modifier species (ModifierSpeciesReference object) in the list of modifiers in this Reaction and returns a pointer to it.

The caller owns the returned object and is responsible for deleting it. The caller should first call getNumModifiers() to find out how many modifiers there are, to avoid using an invalid index number.

Parameters
nthe index of the ModifierSpeciesReference object to remove
Returns
the removed ModifierSpeciesReference object, or NULL if the given index is out of range.
ModifierSpeciesReference * Reaction::removeModifier ( const std::string &  species)

Removes the modifier species (ModifierSpeciesReference object) having the given "species" attribute in this Reaction and returns a pointer to it.

The caller owns the returned object and is responsible for deleting it.

Parameters
speciesthe "species" attribute of the ModifierSpeciesReference object
Returns
the removed ModifierSpeciesReference object, or NULL if no ModifierSpeciesReference object with the given "species" attribute species exists in this Reaction.
SpeciesReference * Reaction::removeProduct ( unsigned int  n)

Removes the nth product species (SpeciesReference object) in the list of products in this Reaction and returns a pointer to it.

The caller owns the returned object and is responsible for deleting it. The caller should first call getNumProducts() to find out how many products there are, to avoid using an invalid index number.

Parameters
nthe index of the product SpeciesReference object to remove
Returns
the removed product SpeciesReference object, or NULL if the given index is out of range.
SpeciesReference * Reaction::removeProduct ( const std::string &  species)

Removes the product species (SpeciesReference object) having the given "species" attribute in this Reaction and returns a pointer to it.

The caller owns the returned object and is responsible for deleting it.

Parameters
speciesthe "species" attribute of the product SpeciesReference object
Returns
the removed product SpeciesReference object, or NULL if no product SpeciesReference object with the given "species" attribute species exists in this Reaction.
SpeciesReference * Reaction::removeReactant ( unsigned int  n)

Removes the nth reactant species (SpeciesReference object) in the list of reactants in this Reaction and returns a pointer to it.

The caller owns the returned object and is responsible for deleting it. The caller should first call getNumReactants() to find out how many reactants there are, to avoid using an invalid index number.

Parameters
nthe index of the reactant SpeciesReference object to remove
Returns
the removed reactant SpeciesReference object, or NULL if the given index is out of range.
SpeciesReference * Reaction::removeReactant ( const std::string &  species)

Removes the reactant species (SpeciesReference object) having the given "species" attribute in this Reaction and returns a pointer to it.

The caller owns the returned object and is responsible for deleting it.

Parameters
speciesthe "species" attribute of the reactant SpeciesReference object
Returns
the removed reactant SpeciesReference object, or NULL if no reactant SpeciesReference object with the given "species" attribute species exists in this Reaction.
int SBase::removeTopLevelAnnotationElement ( const std::string  elementName,
const std::string  elementURI = "",
bool  removeEmpty = true 
)
inherited

Removes the top-level element within the "annotation" subelement of this SBML object with the given name and optional URI.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

Calling this method allows a particular annotation element to be removed whilst the remaining annotations remain intact.

Parameters
elementNamea string representing the name of the top level annotation element that is to be removed
elementURIan optional string that is used to check both the name and URI of the top level element to be removed
removeEmptyif after removing of the element, the annotation is empty, and the removeEmpty argument is true, the annotation node will be deleted (default).
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
replaceTopLevelAnnotationElement(const XMLNode *)
replaceTopLevelAnnotationElement(const std::string&)
void SBase::renameMetaIdRefs ( const std::string &  oldid,
const std::string &  newid 
)
virtualinherited

Renames all the meta-identifier attributes on this element.

In SBML, object "meta" identifiers are of the XML data type ID; the SBML object attribute itself is typically named metaid. All attributes that hold values referring to values of type ID are of the XML data type IDREF. They are also sometimes informally referred to as "metaid refs", in analogy to the SBML-defined type SIdRef.

This method works by looking at all meta-identifier attribute values, comparing the identifiers to the value of oldid. If any matches are found, the matching identifiers are replaced with newid. The method does not descend into child elements.

Parameters
oldidthe old identifier
newidthe new identifier

Reimplemented in Port, and GraphicalObject.

void Reaction::renameSIdRefs ( const std::string &  oldid,
const std::string &  newid 
)
virtual

Renames all the SIdRef attributes on this element, including any found in MathML.

In SBML, object identifiers are of a data type called SId. In SBML Level 3, an explicit data type called SIdRef was introduced for attribute values that refer to SId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as "referring to an identifier", but the effective data type was the same as SIdRefin Level 3. These and other methods of libSBML refer to the type SIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type.

This method works by looking at all attributes and (if appropriate) mathematical formulas, comparing the identifiers to the value of oldid. If any matches are found, the matching identifiers are replaced with newid. The method does not descend into child elements.

Parameters
oldidthe old identifier
newidthe new identifier

Reimplemented from SBase.

void SBase::renameUnitSIdRefs ( const std::string &  oldid,
const std::string &  newid 
)
virtualinherited

Renames all the UnitSIdRef attributes on this element.

In SBML, unit definitions have identifiers of type UnitSId. In SBML Level 3, an explicit data type called UnitSIdRef was introduced for attribute values that refer to UnitSId values; in previous Levels of SBML, this data type did not exist and attributes were simply described to as "referring to a unit identifier", but the effective data type was the same as UnitSIdRef in Level 3. These and other methods of libSBML refer to the type UnitSIdRef for all Levels of SBML, even if the corresponding SBML specification did not explicitly name the data type.

This method works by looking at all unit identifier attribute values (including, if appropriate, inside mathematical formulas), comparing the unit identifiers to the value of oldid. If any matches are found, the matching identifiers are replaced with newid. The method does not descend into child elements.

Parameters
oldidthe old identifier
newidthe new identifier

Reimplemented in Model, Species, Compartment, KineticLaw, Rule, Parameter, EventAssignment, InitialAssignment, StoichiometryMath, Delay, FunctionDefinition, Trigger, Priority, Constraint, and Port.

int SBase::replaceTopLevelAnnotationElement ( const XMLNode annotation)
inherited

Replaces the given top-level element within the "annotation" subelement of this SBML object and with the annotation element supplied.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

This method determines the name of the element to be replaced from the annotation argument. Functionally it is equivalent to calling removeTopLevelAnnotationElement(name) followed by calling appendAnnotation(annotation_with_name), with the exception that the placement of the annotation element remains the same.

Parameters
annotationXMLNode representing the replacement top level annotation
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
removeTopLevelAnnotationElement(const std::string elementName, const std::string elementURI)
replaceTopLevelAnnotationElement(const std::string&)
int SBase::replaceTopLevelAnnotationElement ( const std::string &  annotation)
inherited

Replaces the given top-level element within the "annotation" subelement of this SBML object and with the annotation element supplied.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

This method determines the name of the element to be replaced from the annotation argument. Functionally it is equivalent to calling removeTopLevelAnnotationElement(name) followed by calling appendAnnotation(annotation_with_name), with the exception that the placement of the annotation element remains the same.

Parameters
annotationstring representing the replacement top level annotation
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
removeTopLevelAnnotationElement(const std::string elementName, const std::string elementURI)
replaceTopLevelAnnotationElement(const XMLNode*)
int SBase::setAnnotation ( const XMLNode annotation)
virtualinherited

Sets the value of the "annotation" subelement of this SBML object.

The content of annotation is copied, and any previous content of this object's "annotation" subelement is deleted.

Whereas the SBase "notes" subelement is a container for content to be shown directly to humans, the "annotation" element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for "annotation". The element's content type is XML type "any", allowing essentially arbitrary well-formed XML data content.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

Call this method will result in any existing content of the "annotation" subelement to be discarded. Unless you have taken steps to first copy and reconstitute any existing annotations into the annotation that is about to be assigned, it is likely that performing such wholesale replacement is unfriendly towards other software applications whose annotations are discarded. An alternative may be to use SBase::appendAnnotation(const XMLNode* annotation) or SBase::appendAnnotation(const std::string& annotation).

Parameters
annotationan XML structure that is to be used as the new content of the "annotation" subelement of this object
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
getAnnotationString()
isSetAnnotation()
setAnnotation(const std::string& annotation)
appendAnnotation(const XMLNode* annotation)
appendAnnotation(const std::string& annotation)
unsetAnnotation()

Reimplemented in Model, and SpeciesReference.

int SBase::setAnnotation ( const std::string &  annotation)
virtualinherited

Sets the value of the "annotation" subelement of this SBML object.

The content of annotation is copied, and any previous content of this object's "annotation" subelement is deleted.

Whereas the SBase "notes" subelement is a container for content to be shown directly to humans, the "annotation" element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for "annotation". The element's content type is XML type "any", allowing essentially arbitrary well-formed XML data content.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

Call this method will result in any existing content of the "annotation" subelement to be discarded. Unless you have taken steps to first copy and reconstitute any existing annotations into the annotation that is about to be assigned, it is likely that performing such wholesale replacement is unfriendly towards other software applications whose annotations are discarded. An alternative may be to use SBase::appendAnnotation(const XMLNode* annotation) or SBase::appendAnnotation(const std::string& annotation).

Parameters
annotationan XML string that is to be used as the content of the "annotation" subelement of this object
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
getAnnotationString()
isSetAnnotation()
setAnnotation(const XMLNode* annotation)
appendAnnotation(const XMLNode* annotation)
appendAnnotation(const std::string& annotation)
unsetAnnotation()

Reimplemented in Model, and SpeciesReference.

int Reaction::setCompartment ( const std::string &  sid)

Sets the value of the "compartment" attribute of this Reaction.

The string sid is copied.

Parameters
sidthe string to use as the compartment of this Reaction
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
The "compartment" attribute is available in SBML Level 3 Version 1 Core, but is not present on Reaction in lower Levels of SBML.
void SBase::setElementText ( const std::string &  text)
protectedvirtualinherited

When overridden allows SBase elements to use the text included in between the elements tags.

The default implementation does nothing.

Parameters
textthe text string found between the element tags.
int Reaction::setFast ( bool  value)

Sets the value of the "fast" attribute of this Reaction.

Parameters
valuethe value of the "fast" attribute.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Warning
SBML definitions before SBML Level 2 Version 2 incorrectly indicated that software tools could ignore the "fast" attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and "fast" cannot be ignored if it is set to true. Beginning with SBML Level 2 Versions 2, the SBML specifications therefore stipulate that if a model has any reactions with "fast" set to true, a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Readers are directed to the SBML specifications, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense.
int Reaction::setId ( const std::string &  sid)
virtual

Sets the value of the "id" attribute of this Reaction.

The string sid is copied.

SBML has strict requirements for the syntax of identifiers, that is, the values of the "id" attribute present on most types of SBML objects. The following is a summary of the definition of the SBML identifier type SId, which defines the permitted syntax of identifiers. We express the syntax using an extended form of BNF notation:
   letter ::= 'a'..'z','A'..'Z'
   digit  ::= '0'..'9'
   idChar ::= letter | digit | '_'
   SId    ::= ( letter | '_' ) idChar*
   
The characters ( and ) are used for grouping, the character * "zero or more times", and the character | indicates logical "or". The equality of SBML identifiers is determined by an exact character sequence match; i.e., comparisons must be performed in a case-sensitive manner. In addition, there are a few conditions for the uniqueness of identifiers in an SBML model. Please consult the SBML specifications for the exact details of the uniqueness requirements.
Parameters
sidthe string to use as the identifier of this Reaction
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Examples:
createExampleSBML.cpp.
int Reaction::setKineticLaw ( const KineticLaw kl)

Sets the "kineticLaw" subelement of this Reaction to a copy of the given KineticLaw object.

Parameters
klthe KineticLaw object to use.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
int SBase::setMetaId ( const std::string &  metaid)
inherited

Sets the value of the meta-identifier attribute of this object.

The optional attribute named "metaid", present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each "metaid" value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the "metaid" attribute used by SBML—something to be aware of if your application-specific XML content inside the "annotation" subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the "metaid" attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the "annotation" subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support.

The string metaid is copied.

Parameters
metaidthe identifier string to use as the value of the "metaid" attribute
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
getMetaId()
isSetMetaId()
Examples:
addingEvidenceCodes_1.cpp, and addingEvidenceCodes_2.cpp.
int SBase::setModelHistory ( ModelHistory history)
inherited

Sets the ModelHistory of this object.

The content of history is copied, and this object's existing model history content is deleted.

Parameters
historyModelHistory of this object.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
In SBML Level 2, model history annotations were only permitted on the Model element. In SBML Level 3, they are permitted on all SBML components derived from SBase.
Examples:
addModelHistory.cpp.
int Reaction::setName ( const std::string &  name)
virtual

Sets the value of the "name" attribute of this Reaction.

The string in name is copied.

Parameters
namethe new name for the Reaction
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
int SBase::setNamespaces ( XMLNamespaces xmlns)
inherited

Sets the namespaces relevant of this SBML object.

The content of xmlns is copied, and this object's existing namespace content is deleted.

The SBMLNamespaces object encapsulates SBML Level/Version/namespaces information. It is used to communicate the SBML Level, Version, and (in Level 3) packages used in addition to SBML Level 3 Core.

Parameters
xmlnsthe namespaces to set
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
int SBase::setNotes ( const XMLNode notes)
inherited

Sets the value of the "notes" subelement of this SBML object.

The content of notes is copied, and any existing content of this object's "notes" subelement is deleted.

The optional SBML element named "notes", present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the "notes" element would be to contain formatted user comments about the model element in which the "notes" element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for "notes", allowing users considerable freedom when adding comments to their models.

The format of "notes" elements must be XHTML 1.0. To help verify the formatting of "notes" content, libSBML provides the static utility method SyntaxChecker::hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and  3 specifications have considerable detail about how "notes" element content must be structured.

Parameters
notesan XML structure that is to be used as the content of the "notes" subelement of this object
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
getNotesString()
isSetNotes()
setNotes(const std::string& notes, bool addXHTMLMarkup)
appendNotes(const XMLNode* notes)
appendNotes(const std::string& notes)
unsetNotes()
SyntaxChecker::hasExpectedXHTMLSyntax()
Examples:
createExampleSBML.cpp.
int SBase::setNotes ( const std::string &  notes,
bool  addXHTMLMarkup = false 
)
inherited

Sets the value of the "notes" subelement of this SBML object to a copy of the string notes.

The content of notes is copied, and any existing content of this object's "notes" subelement is deleted.

The optional SBML element named "notes", present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the "notes" element would be to contain formatted user comments about the model element in which the "notes" element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for "notes", allowing users considerable freedom when adding comments to their models.

The format of "notes" elements must be XHTML 1.0. To help verify the formatting of "notes" content, libSBML provides the static utility method SyntaxChecker::hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and  3 specifications have considerable detail about how "notes" element content must be structured.

The following code illustrates a very simple way of setting the notes using this method. Here, the object being annotated is the whole SBML document, but that is for illustration purposes only; you could of course use this same approach to annotate any other SBML component.

Parameters
notesan XML string that is to be used as the content of the "notes" subelement of this object
addXHTMLMarkupa boolean indicating whether to wrap the contents of the notes argument with XHTML paragraph (<p>) tags. This is appropriate when the string in notes does not already containg the appropriate XHTML markup.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
getNotesString()
isSetNotes()
setNotes(const XMLNode* notes)
appendNotes(const XMLNode* notes)
appendNotes(const std::string& notes)
unsetNotes()
SyntaxChecker::hasExpectedXHTMLSyntax()
int Reaction::setReversible ( bool  value)

Sets the value of the "reversible" attribute of this Reaction.

Parameters
valuethe value of the "reversible" attribute.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Examples:
createExampleSBML.cpp.
int SBase::setSBOTerm ( int  value)
virtualinherited

Sets the value of the "sboTerm" attribute.

Beginning with SBML Level 2 Version 3, objects derived from SBase have an optional attribute named "sboTerm" for supporting the use of the Systems Biology Ontology. In SBML proper, the data type of the attribute is a string of the form "SBO:NNNNNNN", where "NNNNNNN" is a seven digit integer number; libSBML simplifies the representation by only storing the "NNNNNNN" integer portion. Thus, in libSBML, the "sboTerm" attribute on SBase has data type int, and SBO identifiers are stored simply as integers.

SBO terms are a type of optional annotation, and each different class of SBML object derived from SBase imposes its own requirements about the values permitted for "sboTerm". Please consult the SBML Level 2 Version 4 specification for more information about the use of SBO and the "sboTerm" attribute.

Parameters
valuethe NNNNNNN integer portion of the SBO identifier
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
setSBOTerm(const std::string &sboid)
int SBase::setSBOTerm ( const std::string &  sboid)
virtualinherited

Sets the value of the "sboTerm" attribute by string.

Beginning with SBML Level 2 Version 3, objects derived from SBase have an optional attribute named "sboTerm" for supporting the use of the Systems Biology Ontology. In SBML proper, the data type of the attribute is a string of the form "SBO:NNNNNNN", where "NNNNNNN" is a seven digit integer number; libSBML simplifies the representation by only storing the "NNNNNNN" integer portion. Thus, in libSBML, the "sboTerm" attribute on SBase has data type int, and SBO identifiers are stored simply as integers. This method lets you set the value of "sboTerm" as a complete string of the form "SBO:NNNNNNN", whereas setSBOTerm(int value) allows you to set it using the integer form.

SBO terms are a type of optional annotation, and each different class of SBML object derived from SBase imposes its own requirements about the values permitted for "sboTerm". Please consult the SBML Level 2 Version 4 specification for more information about the use of SBO and the "sboTerm" attribute.

Parameters
sboidthe SBO identifier string of the form "SBO:NNNNNNN"
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
setSBOTerm(int value)
int SBase::setUserData ( void *  userData)
inherited

Sets the user data of this element.

The user data associated with an SBML object can be used by an application developer to attach custom information to that object in the model. In case of a deep copy, this attribute will passed as it is. The attribute will be never interpreted by libSBML.
Parameters
userDataspecifies the new user data.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
char * SBase::toSBML ( )
inherited

Returns a string consisting of a partial SBML corresponding to just this object.

Returns
the partial SBML that describes this SBML object.
Warning
This is primarily provided for testing and debugging purposes. It may be removed in a future version of libSBML.
XMLNode* SBase::toXMLNode ( )
inherited

Returns this element as an XMLNode.

Returns
this element as an XMLNode.
Warning
This operation is computationally expensive, because the element has to be fully serialized to a string and then parsed into the XMLNode structure. Attempting to convert a large tree structure (e.g., a large Model) may consume significant computer memory and time.
int SBase::unsetAnnotation ( )
inherited

Unsets the value of the "annotation" subelement of this SBML object.

Whereas the SBase "notes" subelement is a container for content to be shown directly to humans, the "annotation" element is a container for optional software-generated content not meant to be shown to humans. Every object derived from SBase can have its own value for "annotation". The element's content type is XML type "any", allowing essentially arbitrary well-formed XML data content.

SBML places a few restrictions on the organization of the content of annotations; these are intended to help software tools read and write the data as well as help reduce conflicts between annotations added by different tools. Please see the SBML specifications for more details.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
getAnnotation()
getAnnotationString()
isSetAnnotation()
setAnnotation(const XMLNode* annotation)
setAnnotation(const std::string& annotation)
appendAnnotation(const XMLNode* annotation)
appendAnnotation(const std::string& annotation)
Examples:
unsetAnnotation.cpp.
int Reaction::unsetCompartment ( )

Unsets the value of the "compartment" attribute of this Reaction.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
The "compartment" attribute is available in SBML Level 3 Version 1 Core, but is not present on Reaction in lower Levels of SBML.
int SBase::unsetCVTerms ( )
inherited

Clears the list of CVTerm objects attached to this SBML object.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
int Reaction::unsetFast ( )

Unsets the value of the "fast" attribute of this Reaction.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Warning
SBML definitions before SBML Level 2 Version 2 incorrectly indicated that software tools could ignore the "fast" attribute if they did not implement support for the corresponding concept; however, further research in SBML has revealed that this is not true, and "fast" cannot be ignored if it is set to true. Beginning with SBML Level 2 Versions 2, the SBML specifications therefore stipulate that if a model has any reactions with "fast" set to true, a software tool must be able to respect the attribute or else indicate to the user that it does not have the capacity to do so. Readers are directed to the SBML specifications, which provides more detail about the conditions under which a reaction can be considered to be fast in this sense.
int SBase::unsetId ( )
virtualinherited

Unsets the value of the "id" attribute of this SBML object.

Most (but not all) objects in SBML include two common attributes: "id" and "name". The identifier given by an object's "id" attribute value is used to identify the object within the SBML model definition. Other objects can refer to the component using this identifier.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:

Reimplemented in Model, Layout, Event, Input, QualitativeSpecies, Output, Objective, SimpleSpeciesReference, Submodel, Transition, GraphicalObject, ExternalModelDefinition, Point, Dimensions, Deletion, Port, BoundingBox, FluxBound, GeneAssociation, and FluxObjective.

int Reaction::unsetKineticLaw ( )

Unsets the "kineticLaw" subelement of this Reaction.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
int SBase::unsetMetaId ( )
inherited

Unsets the value of the "metaid" attribute of this SBML object.

The optional attribute named "metaid", present on every major SBML component type, is for supporting metadata annotations using RDF (Resource Description Format). The attribute value has the data type XML ID, the XML identifier type, which means each "metaid" value must be globally unique within an SBML file. The latter point is important, because the uniqueness criterion applies across any attribute with type ID anywhere in the file, not just the "metaid" attribute used by SBML—something to be aware of if your application-specific XML content inside the "annotation" subelement happens to use the XML ID type. Although SBML itself specifies the use of XML ID only for the "metaid" attribute, SBML-compatible applications should be careful if they use XML ID's in XML portions of a model that are not defined by SBML, such as in the application-specific content of the "annotation" subelement. Finally, note that LibSBML does not provide an explicit XML ID data type; it uses ordinary character strings, which is easier for applications to support.
Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
int SBase::unsetModelHistory ( )
inherited

Unsets the ModelHistory object attached to this object.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
Note
In SBML Level 2, model history annotations were only permitted on the Model element. In SBML Level 3, they are permitted on all SBML components derived from SBase.
int Reaction::unsetName ( )
virtual

Unsets the value of the "name" attribute of this Reaction.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:

Reimplemented from SBase.

int SBase::unsetNotes ( )
inherited

Unsets the value of the "notes" subelement of this SBML object.

The optional SBML element named "notes", present on every major SBML component type, is intended as a place for storing optional information intended to be seen by humans. An example use of the "notes" element would be to contain formatted user comments about the model element in which the "notes" element is enclosed. Every object derived directly or indirectly from type SBase can have a separate value for "notes", allowing users considerable freedom when adding comments to their models.

The format of "notes" elements must be XHTML 1.0. To help verify the formatting of "notes" content, libSBML provides the static utility method SyntaxChecker::hasExpectedXHTMLSyntax(); however, readers are urged to consult the appropriate SBML specification document for the Level and Version of their model for more in-depth explanations. The SBML Level 2 and  3 specifications have considerable detail about how "notes" element content must be structured.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are:
See also
getNotesString()
isSetNotes()
setNotes(const XMLNode* notes)
setNotes(const std::string& notes, bool addXHTMLMarkup)
appendNotes(const XMLNode* notes)
appendNotes(const std::string& notes)
SyntaxChecker::hasExpectedXHTMLSyntax()
Examples:
unsetNotes.cpp.
int SBase::unsetSBOTerm ( )
inherited

Unsets the value of the "sboTerm" attribute of this SBML object.

Returns
integer value indicating success/failure of the function. The possible values returned by this function are: